@popcomputer/structured-chat 0.1.0 → 0.2.0-rc.0

package/dist/core/answer.js

@@ -1,7 +1,11 @@
 import { Effect, Schema } from "effect";
 /** How strongly a collect-stage answer must be grounded in user messages. */
-export const AnswerModeSchema = Schema.Literal("semantic", "explicit", "confirmed");
-const AnswerDescriptionSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(1_000));
+export const AnswerModeSchema = Schema.Literals([
+    "semantic",
+    "explicit",
+    "confirmed",
+]);
+const AnswerDescriptionSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(1_000));
 const defineAnswer = (mode, schema, input) => {
     if (input.ask._tag === "ChoiceQuestion") {
         for (const option of input.ask.options) {
@@ -27,18 +31,23 @@ const defineAnswer = (mode, schema, input) => {
         description: Schema.decodeSync(AnswerDescriptionSchema)(input.description),
         question: input.ask,
     };
-    const withEscape = input.escape === undefined
-        ? base
-        : {
-            ...base,
-            escape: {
-                value: Schema.validateSync(schema)(input.escape.value),
-            },
-        };
+    if (input.escape === undefined) {
+        return input.validate === undefined
+            ? base
+            : {
+                ...base,
+                validate: input.validate,
+                reject: input.reject,
+            };
+    }
+    const escape = {
+        value: Schema.decodeSync(Schema.toType(schema))(input.escape.value),
+    };
     return input.validate === undefined
-        ? withEscape
+        ? { ...base, escape }
         : {
-            ...withEscape,
+            ...base,
+            escape,
             validate: input.validate,
             reject: input.reject,
         };

package/dist/core/chat.d.ts

@@ -1,5 +1,4 @@
 import { Effect, Schema } from "effect";
-import type * as ParseResult from "effect/ParseResult";
 import type { AcceptedAnswer, CollectAnswers, CollectStage, CollectStageDefinitionContract, CollectStagePrompt, CollectStageState } from "./collect-stage.js";
 import { type UntrustedMessage } from "./model.js";
 import { type CommandStage, type CommandStageDefinitionContract, type ToolStage, type ToolStageDefinitionContract } from "./stage.js";
@@ -7,17 +6,15 @@ import type { ToolSetExecution } from "./tool-set.js";
 import type { StandardRepair } from "./repair.js";
 import { ChatSessionConflict, ChatSessionStore, InvalidChatSession, type ChatSessionStoreUnavailable } from "./session.js";
 /** Stable machine-facing name for one structured chat definition. */
-export declare const ChatNameSchema: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
+export declare const ChatNameSchema: Schema.Trimmed;
 /** Positive persisted-state version for one structured chat definition. */
-export declare const ChatVersionSchema: Schema.filter<Schema.filter<typeof Schema.Number>>;
+export declare const ChatVersionSchema: Schema.Number;
 /** Safe reason that a server-owned chat transition was rejected. */
-export declare const InvalidChatTransitionReasonSchema: Schema.Literal<["already_complete", "invalid_state"]>;
-declare const InvalidChatTransition_base: Schema.TaggedErrorClass<InvalidChatTransition, "InvalidChatTransition", {
-    readonly _tag: Schema.tag<"InvalidChatTransition">;
-} & {
-    chat: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
-    reason: Schema.Literal<["already_complete", "invalid_state"]>;
-}>;
+export declare const InvalidChatTransitionReasonSchema: Schema.Literals<readonly ["already_complete", "invalid_state"]>;
+declare const InvalidChatTransition_base: Schema.Class<InvalidChatTransition, Schema.TaggedStruct<"InvalidChatTransition", {
+    readonly chat: Schema.Trimmed;
+    readonly reason: Schema.Literals<readonly ["already_complete", "invalid_state"]>;
+}>, import("effect/Cause").YieldableError>;
 /** A server-owned chat state cannot perform the requested transition. */
 export declare class InvalidChatTransition extends InvalidChatTransition_base {
 }
@@ -50,12 +47,12 @@ export interface ChatState<Name extends string, Version extends number, Stages e
     };
 }
 type ChatQuestion<Stage> = Stage extends CollectStage<infer _Name, infer Fields, infer _Guards> ? CollectStagePrompt<Fields> : never;
-type ChatToolExecution<Stage> = Stage extends ToolStage<infer _Name, infer Tools, infer _Guards> ? ToolSetExecution<Tools> : Stage extends CommandStage<infer _Name, infer _Command, infer _Guards> ? Extract<Effect.Effect.Success<ReturnType<Stage["run"]>>, object> : never;
+type ChatToolExecution<Stage> = Stage extends ToolStage<infer _Name, infer Tools, infer _Guards> ? ToolSetExecution<Tools> : Stage extends CommandStage<infer _Name, infer _Command, infer _Guards> ? Extract<Effect.Success<ReturnType<Stage["run"]>>, object> : never;
 type StageEffect<Stage> = Stage extends CollectStage<infer _CollectName, infer _Fields, infer _CollectGuards> ? ReturnType<Stage["run"]> : Stage extends ToolStage<infer _ToolName, infer _Tools, infer _ToolGuards> ? ReturnType<Stage["run"]> : Stage extends CommandStage<infer _CommandName, infer _Command, infer _CommandGuards> ? ReturnType<Stage["run"]> : never;
 /** Failure union produced by any stage in one chat. */
-export type ChatError<Stages extends ChatStageTuple> = InvalidChatTransition | Effect.Effect.Error<StageEffect<Stages[number]>>;
+export type ChatError<Stages extends ChatStageTuple> = InvalidChatTransition | Effect.Error<StageEffect<Stages[number]>>;
 /** Effect service union required by any stage in one chat. */
-export type ChatRequirements<Stages extends ChatStageTuple> = Effect.Effect.Context<StageEffect<Stages[number]>>;
+export type ChatRequirements<Stages extends ChatStageTuple> = Effect.Services<StageEffect<Stages[number]>>;
 /** Question, ongoing tool result, or terminal result emitted by one turn. */
 export type ChatTurn<Name extends string, Version extends number, Stages extends ChatStageTuple> = {
     readonly _tag: "Question";
@@ -100,12 +97,12 @@ export interface ChatDefinition<Name extends string, Version extends number, Sta
     readonly version: Version;
     readonly stages: Stages;
     readonly repair: StandardRepair | undefined;
-    readonly stateSchema: Schema.Schema<ChatState<Name, Version, Stages>, unknown, never>;
+    readonly stateSchema: Schema.Codec<ChatState<Name, Version, Stages>, unknown>;
     readonly initialState: ChatState<Name, Version, Stages>;
     /** Read one accepted value together with its supporting transcript data. */
     readonly getAcceptedAnswer: <Stage extends ChatCollectStage<Stages>, Field extends keyof CollectFields<Stage> & string>(state: ChatState<Name, Version, Stages>, stage: Stage, field: Field) => AcceptedAnswer<CollectAnswers<CollectFields<Stage>>[Field]> | undefined;
     /** Strictly parse persisted server-owned chat state. */
-    readonly parseState: (input: Schema.Schema.Encoded<Schema.Schema<ChatState<Name, Version, Stages>, unknown, never>>) => Effect.Effect<ChatState<Name, Version, Stages>, ParseResult.ParseError>;
+    readonly parseState: (input: Schema.Codec.Encoded<Schema.Codec<ChatState<Name, Version, Stages>, unknown>>) => Effect.Effect<ChatState<Name, Version, Stages>, Schema.SchemaError>;
     /** Run the active stage and any immediately reachable tool stage. */
     readonly run: (input: {
         readonly state: ChatState<Name, Version, Stages>;

package/dist/core/chat.js

@@ -1,4 +1,4 @@
-import { Effect, Schema, unsafeCoerce } from "effect";
+import { cast, Effect, Schema } from "effect";
 import { readCollectStageRuntime } from "./collect-stage.js";
 import { countUntrustedMessageCharacters, UntrustedMessageSchema, } from "./model.js";
 import { readCommandStageRuntime, readToolStageRuntime, } from "./stage.js";
@@ -7,11 +7,14 @@ import { deriveCommandId } from "./command.js";
 import { defineTool } from "./tool.js";
 import { ChatSessionConflict, ChatSessionIdSchema, ChatSessionNamespaceSchema, ChatSessionReplacementSchema, ChatSessionRevisionSchema, ChatSessionSnapshotSchema, ChatSessionStore, InvalidChatSession, } from "./session.js";
 /** Stable machine-facing name for one structured chat definition. */
-export const ChatNameSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(100), Schema.pattern(/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/));
+export const ChatNameSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(100), Schema.isPattern(/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/));
 /** Positive persisted-state version for one structured chat definition. */
-export const ChatVersionSchema = Schema.Number.pipe(Schema.int(), Schema.between(1, 2_147_483_647));
+export const ChatVersionSchema = Schema.Number.check(Schema.isInt(), Schema.isBetween({ minimum: 1, maximum: 2_147_483_647 }));
 /** Safe reason that a server-owned chat transition was rejected. */
-export const InvalidChatTransitionReasonSchema = Schema.Literal("already_complete", "invalid_state");
+export const InvalidChatTransitionReasonSchema = Schema.Literals([
+    "already_complete",
+    "invalid_state",
+]);
 /** A server-owned chat state cannot perform the requested transition. */
 export class InvalidChatTransition extends Schema.TaggedError()("InvalidChatTransition", {
     chat: ChatNameSchema,
@@ -90,9 +93,9 @@ export const defineChat = (definition) => {
         }
         const correctionSchema = remainingSchemas.length === 0
             ? firstSchema
-            : Schema.Union(firstSchema, ...remainingSchemas);
+            : Schema.Union([firstSchema, ...remainingSchemas]);
         const input = Schema.Struct({
-            corrections: Schema.NonEmptyArray(correctionSchema).pipe(Schema.maxItems(repair.maximumCorrections)),
+            corrections: Schema.NonEmptyArray(correctionSchema).check(Schema.isMaxLength(repair.maximumCorrections)),
         });
         return defineTool({
             name: repairToolName,
@@ -164,8 +167,11 @@ export const defineChat = (definition) => {
     const baseStateFields = {
         schemaVersion: Schema.Literal(definition.version),
         chat: Schema.Literal(definition.name),
-        stage: Schema.Number.pipe(Schema.int(), Schema.between(0, definition.stages.length - 1)),
-        status: Schema.Literal("active", "complete"),
+        stage: Schema.Number.check(Schema.isInt(), Schema.isBetween({
+            minimum: 0,
+            maximum: definition.stages.length - 1,
+        })),
+        status: Schema.Literals(["active", "complete"]),
         stages: Schema.Struct(stateFields),
     };
     const rawStateSchema = repair === undefined
@@ -173,18 +179,21 @@ export const defineChat = (definition) => {
         : Schema.Struct({
             ...baseStateFields,
             repair: Schema.Struct({
-                pendingStages: Schema.Array(Schema.Number.pipe(Schema.int(), Schema.between(0, finalStageIndex - 1))).pipe(Schema.maxItems(20)),
+                pendingStages: Schema.Array(Schema.Number.check(Schema.isInt(), Schema.isBetween({
+                    minimum: 0,
+                    maximum: finalStageIndex - 1,
+                }))).check(Schema.isMaxLength(20)),
             }),
         });
     // SAFETY: the conditional repair field is erased only for applying the
     // shared semantic predicate; stateSchema below restores the public type.
-    const runtimeStateSchema = unsafeCoerce(rawStateSchema);
-    const refinedStateSchema = runtimeStateSchema.pipe(Schema.filter((state) => isValidRuntimeState(unsafeCoerce(state)), {
+    const runtimeStateSchema = cast(rawStateSchema);
+    const refinedStateSchema = runtimeStateSchema.check(Schema.makeFilter((state) => isValidRuntimeState(cast(state)), {
         description: "semantically valid structured-chat state",
     }));
     // SAFETY: stage state fields are taken directly from the concrete collect
     // stages, and the remaining envelope fields are exact literals or bounds.
-    const stateSchema = unsafeCoerce(refinedStateSchema);
+    const stateSchema = cast(refinedStateSchema);
     const baseInitialState = {
         schemaVersion: definition.version,
         chat: definition.name,
@@ -195,7 +204,7 @@ export const defineChat = (definition) => {
     const initialStateInput = repair === undefined
         ? baseInitialState
         : { ...baseInitialState, repair: { pendingStages: [] } };
-    const initialState = Schema.validateSync(stateSchema)(initialStateInput);
+    const initialState = Schema.decodeUnknownSync(Schema.toType(stateSchema))(initialStateInput);
     const isGroundedInMessages = (state, messages) => definition.stages.every((stage) => {
         if (stage._tag !== "CollectStage") {
             return true;
@@ -279,7 +288,7 @@ export const defineChat = (definition) => {
                     }
                     // SAFETY: planWith used the generated repair tool schema, and this
                     // branch is selected by that tool's unique literal name.
-                    const proposal = unsafeCoerce(call.arguments);
+                    const proposal = cast(call.arguments);
                     return applyConversationRepairs(state, messages, proposal.corrections).pipe(Effect.flatMap((repairedState) => Effect.suspend(() => runTrustedRuntime(repairedState, messages, commandContext, false))));
                 }));
             }
@@ -348,14 +357,14 @@ export const defineChat = (definition) => {
     const run = (input) => {
         // SAFETY: ChatState is generated from the same stage tuple as the sealed
         // runtime state contract; only generic correlations are erased here.
-        const runtimeState = unsafeCoerce(input.state);
+        const runtimeState = cast(input.state);
         const runtime = runCheckedRuntime(runtimeState, input.messages);
         // SAFETY: runtime dispatch follows the exact Stages tuple and each stage
         // retains its own parsing, errors, dependencies, and output constructor.
-        return unsafeCoerce(runtime);
+        return cast(runtime);
     };
     const reply = (input) => Effect.gen(function* () {
-        const parsedInput = yield* Schema.decodeUnknown(ChatReplyBoundaryInputSchema)(input, { onExcessProperty: "error" }).pipe(Effect.mapError(() => invalidSession("invalid_input")));
+        const parsedInput = yield* Schema.decodeUnknownEffect(ChatReplyBoundaryInputSchema)(input, { onExcessProperty: "error" }).pipe(Effect.mapError(() => invalidSession("invalid_input")));
         const store = yield* ChatSessionStore;
         const scope = {
             namespace: parsedInput.namespace ?? "",
@@ -371,7 +380,7 @@ export const defineChat = (definition) => {
         }));
         const snapshot = loaded === null
             ? null
-            : yield* Schema.decodeUnknown(ChatSessionSnapshotSchema)(loaded, { onExcessProperty: "error" }).pipe(Effect.mapError(() => invalidSession("invalid_snapshot")));
+            : yield* Schema.decodeUnknownEffect(ChatSessionSnapshotSchema)(loaded, { onExcessProperty: "error" }).pipe(Effect.mapError(() => invalidSession("invalid_snapshot")));
         if ((snapshot === null &&
             parsedInput.expectedRevision !== undefined) ||
             (snapshot !== null &&
@@ -380,12 +389,12 @@ export const defineChat = (definition) => {
         }
         const state = snapshot === null
             ? initialState
-            : yield* Schema.decodeUnknown(stateSchema)(snapshot.state, {
+            : yield* Schema.decodeUnknownEffect(stateSchema)(snapshot.state, {
                 onExcessProperty: "error",
             }).pipe(Effect.mapError(() => invalidSession("invalid_state")));
         const previousMessages = snapshot?.messages ?? [];
         // SAFETY: stateSchema decoded this definition's exact state envelope.
-        const runtimeState = unsafeCoerce(state);
+        const runtimeState = cast(state);
         if (!isGroundedInMessages(runtimeState, previousMessages)) {
             return yield* Effect.fail(invalidSession("invalid_state"));
         }
@@ -393,7 +402,7 @@ export const defineChat = (definition) => {
             maximumPersistedMessages) {
             return yield* Effect.fail(invalidSession("history_limit"));
         }
-        const userMessage = yield* Schema.decodeUnknown(UntrustedMessageSchema)({ role: "user", content: parsedInput.message }, { onExcessProperty: "error" }).pipe(Effect.mapError(() => invalidSession("invalid_input")));
+        const userMessage = yield* Schema.decodeUnknownEffect(UntrustedMessageSchema)({ role: "user", content: parsedInput.message }, { onExcessProperty: "error" }).pipe(Effect.mapError(() => invalidSession("invalid_input")));
         const messages = [...previousMessages, userMessage];
         const commandContext = finalStage?._tag === "CommandStage"
             ? {
@@ -414,7 +423,7 @@ export const defineChat = (definition) => {
             snapshot !== null &&
             state.status === "active" &&
             state.stage === finalStageIndex);
-        const turn = yield* unsafeCoerce(trustedTurn);
+        const turn = yield* cast(trustedTurn);
         const toolModelContext = turn._tag === "Question"
             ? undefined
             : readToolExecutionModelContext(turn.result);
@@ -438,7 +447,7 @@ export const defineChat = (definition) => {
         if (persistedMessages.length > maximumPersistedMessages) {
             return yield* Effect.fail(invalidSession("history_limit"));
         }
-        const encodedState = yield* Schema.encodeUnknown(stateSchema)(turn.state, { onExcessProperty: "error" }).pipe(Effect.mapError(() => invalidSession("invalid_state")));
+        const encodedState = yield* Schema.encodeUnknownEffect(stateSchema)(turn.state, { onExcessProperty: "error" }).pipe(Effect.mapError(() => invalidSession("invalid_state")));
         const replaced = yield* store
             .replace({
             ...scope,
@@ -456,7 +465,7 @@ export const defineChat = (definition) => {
                 status: turn.state.status,
             },
         }));
-        const replacement = yield* Schema.decodeUnknown(ChatSessionReplacementSchema)(replaced, { onExcessProperty: "error" }).pipe(Effect.mapError(() => invalidSession("invalid_replacement")));
+        const replacement = yield* Schema.decodeUnknownEffect(ChatSessionReplacementSchema)(replaced, { onExcessProperty: "error" }).pipe(Effect.mapError(() => invalidSession("invalid_replacement")));
         return {
             revision: replacement.revision,
             turn,
@@ -477,11 +486,11 @@ export const defineChat = (definition) => {
             }
             // SAFETY: Stage is restricted to this chat's concrete collect stages,
             // Field is restricted to its field keys, and state uses the same tuple.
-            const runtimeState = unsafeCoerce(state);
+            const runtimeState = cast(state);
             const accepted = runtimeState.stages[stage.name]?.accepted[field];
-            return unsafeCoerce(accepted);
+            return cast(accepted);
         },
-        parseState: (input) => Schema.decodeUnknown(stateSchema)(input, {
+        parseState: (input) => Schema.decodeUnknownEffect(stateSchema)(input, {
             onExcessProperty: "error",
         }),
         run,

package/dist/core/collect-stage.d.ts

@@ -1,5 +1,4 @@
 import { Effect, Schema } from "effect";
-import type * as ParseResult from "effect/ParseResult";
 import type { AnswerDefinition, AnswerDefinitionContract, AnswerMode } from "./answer.js";
 import { ChatModelUnavailable, StructuredChatModel, type UnsupportedModelToolSchema, type UntrustedMessage } from "./model.js";
 import type { ModelGuardError, ModelGuardRequirements, ModelGuardTuple } from "./model-guard.js";
@@ -7,13 +6,11 @@ import { InvalidToolCall, type InvalidToolProjection } from "./tool.js";
 import type { AdaptiveChoiceQuestion, ChoiceQuestion, QuestionChoice } from "./question.js";
 import { type StructuredDefinition } from "./definition.js";
 /** Safe reason that a collect-stage model proposal was rejected. */
-export declare const InvalidCollectStageResponseReasonSchema: Schema.Literal<["invalid_evidence", "invalid_repair"]>;
-declare const InvalidCollectStageResponse_base: Schema.TaggedErrorClass<InvalidCollectStageResponse, "InvalidCollectStageResponse", {
-    readonly _tag: Schema.tag<"InvalidCollectStageResponse">;
-} & {
-    stage: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
-    reason: Schema.Literal<["invalid_evidence", "invalid_repair"]>;
-}>;
+export declare const InvalidCollectStageResponseReasonSchema: Schema.Literals<readonly ["invalid_evidence", "invalid_repair"]>;
+declare const InvalidCollectStageResponse_base: Schema.Class<InvalidCollectStageResponse, Schema.TaggedStruct<"InvalidCollectStageResponse", {
+    readonly stage: Schema.Trimmed;
+    readonly reason: Schema.Literals<readonly ["invalid_evidence", "invalid_repair"]>;
+}>, import("effect/Cause").YieldableError>;
 /** A collect-stage proposal was not grounded in a user message. */
 export declare class InvalidCollectStageResponse extends InvalidCollectStageResponse_base {
 }
@@ -104,7 +101,7 @@ export interface CollectStageTurn<Fields extends AnswerFields> {
     readonly complete: boolean;
     readonly question: CollectStagePrompt<Fields> | undefined;
 }
-type RuntimeAnswerValue = Schema.Schema.Type<Schema.Schema.AnyNoContext>;
+type RuntimeAnswerValue = Schema.Schema.Type<Schema.Codec<unknown, unknown>>;
 type RuntimeAcceptedAnswer = AcceptedAnswer<RuntimeAnswerValue>;
 interface RuntimeCollectStageState {
     readonly accepted: Readonly<Partial<Record<string, RuntimeAcceptedAnswer>>>;
@@ -139,12 +136,12 @@ interface RuntimeCollectRepairResult {
 /** @internal Erased collect-stage behavior consumed by the chat runtime. */
 export interface CollectStageRuntime {
     readonly initialState: RuntimeCollectStageState;
-    readonly stateSchema: Schema.Schema.AnyNoContext;
+    readonly stateSchema: Schema.Codec<unknown, unknown>;
     readonly isInitial: (state: RuntimeCollectStageState) => boolean;
     readonly isValid: (state: RuntimeCollectStageState) => boolean;
     readonly isGroundedInMessages: (state: RuntimeCollectStageState, messages: ReadonlyArray<UntrustedMessage>) => boolean;
     readonly isComplete: (state: RuntimeCollectStageState) => boolean;
-    readonly repairSchema: Schema.Schema.AnyNoContext;
+    readonly repairSchema: Schema.Codec<unknown, unknown>;
     readonly applyRepairs: (state: RuntimeCollectStageState, messages: ReadonlyArray<UntrustedMessage>, repairs: ReadonlyArray<RuntimeCollectRepair>) => Effect.Effect<RuntimeCollectRepairResult, unknown, unknown>;
     readonly run: (input: {
         readonly state: RuntimeCollectStageState;
@@ -180,12 +177,12 @@ export interface CollectStage<Name extends string, Fields extends AnswerFields,
     readonly name: Name;
     readonly fields: Fields;
     readonly questions: CollectQuestionPolicy;
-    readonly answersSchema: Schema.Schema<CollectAnswers<Fields>, unknown, never>;
-    readonly stateSchema: Schema.Schema<CollectStageState<Fields>, unknown, never>;
+    readonly answersSchema: Schema.Codec<CollectAnswers<Fields>, unknown>;
+    readonly stateSchema: Schema.Codec<CollectStageState<Fields>, unknown>;
     readonly initialState: CollectStageState<Fields>;
     readonly guards: Guards;
     /** Strictly parse persisted or client-returned stage state. */
-    readonly parseState: (input: Schema.Schema.Encoded<Schema.Schema<CollectStageState<Fields>, unknown, never>>) => Effect.Effect<CollectStageState<Fields>, ParseResult.ParseError>;
+    readonly parseState: (input: Schema.Codec.Encoded<Schema.Codec<CollectStageState<Fields>, unknown>>) => Effect.Effect<CollectStageState<Fields>, Schema.SchemaError>;
     /** Test whether every schema-defined answer has been populated. */
     readonly isComplete: (state: CollectStageState<Fields>) => boolean;
     /** Select the first missing question in schema declaration order. */

package/dist/core/collect-stage.js

@@ -1,11 +1,14 @@
-import { Data, Effect, Either, Schema, unsafeCoerce } from "effect";
+import { cast, Data, Effect, Result, Schema, Struct } from "effect";
 import { StageNameSchema } from "./stage-name.js";
 import { ChatModelUnavailable, Instruction, runToolStep, StructuredChatModel, } from "./model.js";
 import { defineTool, InvalidToolCall, } from "./tool.js";
 import { defineToolSet } from "./tool-set.js";
 import { structuredDefinition, } from "./definition.js";
 /** Safe reason that a collect-stage model proposal was rejected. */
-export const InvalidCollectStageResponseReasonSchema = Schema.Literal("invalid_evidence", "invalid_repair");
+export const InvalidCollectStageResponseReasonSchema = Schema.Literals([
+    "invalid_evidence",
+    "invalid_repair",
+]);
 /** A collect-stage proposal was not grounded in a user message. */
 export class InvalidCollectStageResponse extends Schema.TaggedError()("InvalidCollectStageResponse", {
     stage: StageNameSchema,
@@ -22,8 +25,8 @@ const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
 /** Define one deterministic schema-derived fact collection stage. */
 export const defineCollectStage = (definition) => {
     Schema.decodeSync(StageNameSchema)(definition.name);
-    const questionGuidanceSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(2_000));
-    const questionEscapeSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(100));
+    const questionGuidanceSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(2_000));
+    const questionEscapeSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(100));
     const questionPolicyBuilder = {};
     if (definition.questions?.guidance !== undefined) {
         questionPolicyBuilder.guidance = Schema.decodeSync(questionGuidanceSchema)(definition.questions.guidance);
@@ -34,7 +37,7 @@ export const defineCollectStage = (definition) => {
     const questions = questionPolicyBuilder;
     // SAFETY: definition.fields is the exact Fields mapping; Object.keys returns
     // only its enumerable string keys.
-    const fieldNames = unsafeCoerce(Object.keys(definition.fields));
+    const fieldNames = cast(Object.keys(definition.fields));
     if (fieldNames.length === 0) {
         throw new Error("Collect stages require at least one answer field");
     }
@@ -53,8 +56,8 @@ export const defineCollectStage = (definition) => {
     if (firstField === undefined) {
         throw new Error("Collect stages require at least one answer field");
     }
-    const fieldSchema = Schema.Literal(firstField, ...remainingFields);
-    const messageIndexSchema = Schema.Number.pipe(Schema.int(), Schema.between(0, 1_000_000));
+    const fieldSchema = Schema.Literals([firstField, ...remainingFields]);
+    const messageIndexSchema = Schema.Number.check(Schema.isInt(), Schema.isBetween({ minimum: 0, maximum: 1_000_000 }));
     const getAnswer = (field) => {
         const answer = definition.fields[field];
         if (answer === undefined) {
@@ -91,10 +94,10 @@ export const defineCollectStage = (definition) => {
     }
     const answerSchemaEntries = fieldNames.map((field) => [field, getAnswer(field).schema]);
     // SAFETY: every entry uses one exact Fields key and its corresponding schema.
-    const answerSchemas = unsafeCoerce(Object.fromEntries(answerSchemaEntries));
+    const answerSchemas = cast(Object.fromEntries(answerSchemaEntries));
     const rawAnswersSchema = Schema.Struct(answerSchemas);
-    const evidenceQuoteSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(2_000));
-    const questionTextSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(500));
+    const evidenceQuoteSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(2_000));
+    const questionTextSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(500));
     const acceptedEvidenceSchema = Schema.Struct({
         messageIndex: messageIndexSchema,
         quote: evidenceQuoteSchema,
@@ -126,10 +129,10 @@ export const defineCollectStage = (definition) => {
     }
     const rawRepairSchema = remainingRepairSchemas.length === 0
         ? firstRepairSchema
-        : Schema.Union(firstRepairSchema, ...remainingRepairSchemas);
+        : Schema.Union([firstRepairSchema, ...remainingRepairSchemas]);
     // SAFETY: every dynamically generated member uses only AnyNoContext field
     // schemas and exact stage, field, and transition literals.
-    const repairSchema = rawRepairSchema;
+    const repairSchema = cast(rawRepairSchema);
     const acceptedFields = Object.fromEntries(fieldNames.map((field) => [
         field,
         Schema.Struct({
@@ -145,8 +148,8 @@ export const defineCollectStage = (definition) => {
         }),
     ]));
     const rawStateSchema = Schema.Struct({
-        accepted: Schema.partial(Schema.Struct(acceptedFields)),
-        asked: Schema.partial(Schema.Struct(askedFields)),
+        accepted: Schema.Struct(acceptedFields).mapFields(Struct.map(Schema.optional)),
+        asked: Schema.Struct(askedFields).mapFields(Struct.map(Schema.optional)),
     });
     const isValidState = (state) => {
         return fieldNames.every((field) => {
@@ -156,49 +159,49 @@ export const defineCollectStage = (definition) => {
                 hasOwn(state.asked, field));
         });
     };
-    const refinedStateSchema = rawStateSchema.pipe(Schema.filter(isValidState, {
+    const refinedStateSchema = rawStateSchema.check(Schema.makeFilter(isValidState, {
         description: "semantically valid collect-stage state",
     }));
     // SAFETY: rawAnswersSchema is created from every field's exact schema.
-    const answersSchema = unsafeCoerce(rawAnswersSchema);
+    const answersSchema = cast(rawAnswersSchema);
     // SAFETY: partial preserves the mapped accepted-answer types, while asked is
     // a record whose keys are restricted to the exact field literal union.
-    const stateSchema = unsafeCoerce(refinedStateSchema);
-    const initialState = Schema.validateSync(stateSchema)({
+    const stateSchema = cast(refinedStateSchema);
+    const initialState = Schema.decodeSync(Schema.toType(stateSchema))({
         accepted: {},
         asked: {},
     });
     // SAFETY: when guards are omitted, Guards uses its readonly [] default; an
     // explicitly supplied tuple is returned unchanged.
-    const guards = definition.guards ?? unsafeCoerce([]);
+    const guards = definition.guards ?? cast([]);
     // SAFETY: every entry is built from one registered AnyNoContext answer
     // schema and adds only the model-wire null representation for absence.
     const proposalAnswerSchemaEntries = fieldNames.map((field) => {
         const answer = getAnswer(field);
         return [
             field,
-            Schema.NullOr(answer.schema).annotations({
+            Schema.NullOr(answer.schema).annotate({
                 description: `${answer.mode}: ${answer.description}`,
             }),
         ];
     });
     // SAFETY: each entry contains one registered field and its no-context schema.
-    const proposalAnswerSchemas = unsafeCoerce(Object.fromEntries(proposalAnswerSchemaEntries));
+    const proposalAnswerSchemas = cast(Object.fromEntries(proposalAnswerSchemaEntries));
     const rawProposalSchema = Schema.Struct({
         answers: Schema.Struct(proposalAnswerSchemas),
         evidence: Schema.Array(Schema.Struct({
             field: fieldSchema,
             quote: evidenceQuoteSchema,
-        })).pipe(Schema.maxItems(fieldNames.length)),
+        })).check(Schema.isMaxLength(fieldNames.length)),
         nextQuestion: Schema.NullOr(Schema.Struct({
             field: fieldSchema,
             text: questionTextSchema,
-            options: Schema.Array(Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(100))).pipe(Schema.maxItems(20)),
+            options: Schema.Array(Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(100))).check(Schema.isMaxLength(20)),
         })),
     });
     // SAFETY: every answer field schema is constrained to AnyNoContext; the
     // generic mapped Struct cannot prove that fact after Object.fromEntries.
-    const ProposalSchema = rawProposalSchema;
+    const ProposalSchema = cast(rawProposalSchema);
     const submitAnswers = defineTool({
         name: "submit_answers",
         description: "Submit grounded answers from the conversation and optionally phrase the next adaptive question.",
@@ -314,11 +317,11 @@ export const defineCollectStage = (definition) => {
             // A selected label is later submitted as this answer's wire value,
             // so model-authored labels that cannot decode would dead-end the
             // user; fall back to the application-authored options instead.
-            const decodeLabel = Schema.decodeUnknownEither(getAnswer(pending.field).schema);
+            const decodeLabel = Schema.decodeUnknownResult(getAnswer(pending.field).schema);
             const validOptions = supplied.length < question.minimumOptions ||
                 supplied.length > question.maximumOptions ||
                 new Set(normalized).size !== normalized.length ||
-                supplied.some(({ label }) => Either.isLeft(decodeLabel(label)))
+                supplied.some(({ label }) => Result.isFailure(decodeLabel(label)))
                 ? undefined
                 : supplied;
             const selectedOptions = validOptions ??
@@ -339,8 +342,8 @@ export const defineCollectStage = (definition) => {
             options,
         };
         return questions.escape === undefined
-            ? unsafeCoerce(prompt)
-            : unsafeCoerce({ ...prompt, escape: { label: questions.escape } });
+            ? cast(prompt)
+            : cast({ ...prompt, escape: { label: questions.escape } });
     };
     const askPendingQuestion = (state, messages, adaptive) => {
         const pending = nextQuestion(state);
@@ -385,8 +388,8 @@ export const defineCollectStage = (definition) => {
             options: question._tag === "ChoiceQuestion" ? question.options : [],
         };
         return questions.escape === undefined
-            ? unsafeCoerce(prompt)
-            : unsafeCoerce({ ...prompt, escape: { label: questions.escape } });
+            ? cast(prompt)
+            : cast({ ...prompt, escape: { label: questions.escape } });
     };
     const validateAnswer = (field, value) => {
         const answer = getAnswer(field);
@@ -395,7 +398,7 @@ export const defineCollectStage = (definition) => {
         }
         // SAFETY: field selects the same answer definition whose schema parsed
         // value before validation, preserving that field's validator input.
-        const validation = unsafeCoerce(answer.validate);
+        const validation = cast(answer.validate);
         return validation(value).pipe(Effect.mapError((error) => new AnswerValidationRejected({
             stage: definition.name,
             field,
@@ -413,7 +416,7 @@ export const defineCollectStage = (definition) => {
         for (const repair of repairs) {
             // SAFETY: the field lookup below rejects names outside Fields before
             // any field-indexed operation runs.
-            const field = unsafeCoerce(repair.field);
+            const field = cast(repair.field);
             const answer = definition.fields[field];
             if (answer === undefined ||
                 seen.has(field) ||
@@ -547,7 +550,7 @@ export const defineCollectStage = (definition) => {
             };
             // SAFETY: accepted keys come only from fieldNames and every value was
             // decoded by that field's schema before insertion.
-            const merged = unsafeCoerce(runtimeMerged);
+            const merged = cast(runtimeMerged);
             if (isComplete(merged)) {
                 return {
                     state: merged,
@@ -577,7 +580,7 @@ export const defineCollectStage = (definition) => {
         // at the first failure. This keeps application Effects and the selected
         // retry question deterministic. Each validator came from the same
         // concrete Fields mapping used by the public conditional unions.
-        return execution;
+        return cast(execution);
     };
     const run = ({ state, messages, }) => {
         if (!isValidState(state) || !isGroundedInMessages(state, messages)) {
@@ -594,12 +597,12 @@ export const defineCollectStage = (definition) => {
                 error.reason === "invalid_response"), (error) => Effect.logWarning("Falling back to the trusted pending question").pipe(Effect.annotateLogs({
             stage: definition.name,
             errorTag: error._tag,
-        }), Effect.as(askPendingQuestion(state, messages, null)))));
+        }), Effect.as(askPendingQuestion(state, messages, null))), (error) => Effect.fail(error)));
     };
     // SAFETY: The chat runtime calls these erased operations only after the
     // generated state schema has parsed this exact collect-stage state. The
     // public lower-level run method already requires CollectStageState<Fields>.
-    const assumeParsedState = (state) => unsafeCoerce(state);
+    const assumeParsedState = (state) => cast(state);
     return structuredDefinition("collect_stage")({
         _tag: "CollectStage",
         name: definition.name,
@@ -609,7 +612,7 @@ export const defineCollectStage = (definition) => {
         stateSchema,
         initialState,
         guards,
-        parseState: (input) => Schema.decodeUnknown(stateSchema)(input, {
+        parseState: (input) => Schema.decodeUnknownEffect(stateSchema)(input, {
             onExcessProperty: "error",
         }),
         isComplete,

package/dist/core/command.d.ts

@@ -1,6 +1,6 @@
 import { Effect, Schema } from "effect";
 /** Opaque deterministic identity supplied to one command execution. */
-export declare const CommandIdSchema: Schema.brand<Schema.filter<typeof Schema.String>, "CommandId">;
+export declare const CommandIdSchema: Schema.brand<Schema.String, "CommandId">;
 /** Opaque deterministic identity supplied to one command execution. */
 export type CommandId = Schema.Schema.Type<typeof CommandIdSchema>;
 /** Inputs whose exact tuple identity defines one command attempt. */

package/dist/core/command.js

@@ -1,6 +1,6 @@
 import { Effect, Schema } from "effect";
 /** Opaque deterministic identity supplied to one command execution. */
-export const CommandIdSchema = Schema.String.pipe(Schema.pattern(/^cmd_[0-9a-f]{64}$/), Schema.brand("CommandId"));
+export const CommandIdSchema = Schema.String.pipe(Schema.check(Schema.isPattern(/^cmd_[0-9a-f]{64}$/)), Schema.brand("CommandId"));
 const toHex = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
 /** Derive the stable idempotency key for one persisted command turn. */
 export const deriveCommandId = (input) => Effect.promise(async () => {

package/dist/core/json-value.d.ts

@@ -8,4 +8,4 @@ export interface JsonObject {
 /** Recursively typed value accepted at serialized JSON boundaries. */
 export type JsonValue = JsonPrimitive | JsonObject | ReadonlyArray<JsonValue>;
 /** Runtime parser for recursively JSON-serializable values. */
-export declare const JsonValueSchema: Schema.Schema<JsonValue>;
+export declare const JsonValueSchema: Schema.Codec<JsonValue>;