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

package/dist/core/tool.js

@@ -1,21 +1,35 @@
-import { Effect, JSONSchema, Pipeable, Schema, unsafeCoerce, } from "effect";
-import * as ParseResult from "effect/ParseResult";
+import { Effect, Function as Fn, JsonSchema, Pipeable, Result, Schema, SchemaIssue, } from "effect";
 import { structuredDefinition, } from "./definition.js";
 /** Stable machine-facing name for one structured chat tool. */
-export const ToolNameSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(100), Schema.pattern(/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/));
+export const ToolNameSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(100), Schema.isPattern(/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/));
 /** Bounded model-facing description for one structured chat tool. */
-export const ToolDescriptionSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(2_000));
+export const ToolDescriptionSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(2_000));
 /** Safe reason that a model-authored tool call was rejected. */
-export const InvalidToolCallReasonSchema = Schema.Literal("invalid_envelope", "unknown_tool", "invalid_arguments");
+export const InvalidToolCallReasonSchema = Schema.Literals([
+    "invalid_envelope",
+    "unknown_tool",
+    "invalid_arguments",
+]);
 /** A model-authored tool call failed strict parsing. */
 export class InvalidToolCall extends Schema.TaggedError()("InvalidToolCall", {
     tool: Schema.NullOr(ToolNameSchema),
     reason: InvalidToolCallReasonSchema,
-    path: Schema.NullOr(Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(500))),
+    path: Schema.NullOr(Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(500))),
 }) {
 }
 /** Safe reason that an application-owned tool projection was rejected. */
-export const InvalidToolProjectionReasonSchema = Schema.Literal("invalid_model_result", "invalid_view_data");
+export const InvalidToolProjectionReasonSchema = Schema.Literals([
+    "invalid_model_result",
+    "invalid_view_data",
+]);
+const StandardSchemaPathSegment = Schema.Struct({
+    key: Schema.Union([
+        Schema.String,
+        Schema.Number,
+        Schema.Symbol,
+    ]),
+});
+const decodeStandardSchemaPathSegment = Schema.decodeUnknownResult(StandardSchemaPathSegment);
 /** An application-owned model or view projection violated its schema. */
 export class InvalidToolProjection extends Schema.TaggedError()("InvalidToolProjection", {
     tool: ToolNameSchema,
@@ -25,21 +39,23 @@ export class InvalidToolProjection extends Schema.TaggedError()("InvalidToolProj
 }
 const toolRuntime = Symbol("@popcomputer/structured-chat/ToolRuntime");
 const toolExecutionModelContext = Symbol("@popcomputer/structured-chat/ToolExecutionModelContext");
-const ToolExecutionModelContextSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(40_000));
+const ToolExecutionModelContextSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(40_000));
 /** @internal Read the bounded model-visible context retained by one execution. */
 export const readToolExecutionModelContext = (execution) => {
-    // SAFETY: Every execution returned by a StructuredTool is constructed by
-    // makeTool below with this package-private symbol property.
-    const runtime = execution;
-    return runtime[toolExecutionModelContext];
+    return execution[toolExecutionModelContext];
 };
-const parseToolCall = (name, callSchema, input) => Schema.decodeUnknown(callSchema)(input, {
+const parseToolCall = (name, callSchema, input) => Schema.decodeUnknownEffect(callSchema)(input, {
     onExcessProperty: "error",
 }).pipe(Effect.mapError((error) => {
-    const issue = ParseResult.ArrayFormatter.formatErrorSync(error)[0];
-    const issuePath = issue === undefined || issue.path.length === 0
+    const issue = SchemaIssue.makeFormatterStandardSchemaV1()(error.issue)
+        .issues[0];
+    const path = issue?.path ?? [];
+    const issuePath = path.length === 0
         ? "#"
-        : `#/${issue.path.map(String).join("/")}`;
+        : `#/${path.map((segment) => Result.match(decodeStandardSchemaPathSegment(segment), {
+            onFailure: () => String(segment),
+            onSuccess: ({ key }) => String(key),
+        })).join("/")}`;
     return new InvalidToolCall({
         tool: name,
         reason: "invalid_arguments",
@@ -50,7 +66,7 @@ const projectModelResult = (tool, projection, result) => {
     if (projection === undefined) {
         // SAFETY: The conditional result type is exactly undefined when no model
         // projection schema is configured.
-        return Effect.succeed(undefined);
+        return Effect.succeed(Fn.cast(undefined));
     }
     const invalidProjection = () => new InvalidToolProjection({
         tool,
@@ -60,21 +76,21 @@ const projectModelResult = (tool, projection, result) => {
     return Effect.try({
         try: () => projection.project(result),
         catch: invalidProjection,
-    }).pipe(Effect.flatMap((projected) => Schema.validate(projection.schema)(projected, {
+    }).pipe(Effect.flatMap((projected) => Schema.decodeEffect(Schema.toType(projection.schema))(projected, {
         onExcessProperty: "error",
     })), Effect.mapError(invalidProjection), 
-    // SAFETY: Schema.validate returned the configured model schema's exact
+    // SAFETY: decoding the Type side returned the configured schema's exact
     // Type side, which is ToolModelResult<ModelSchema> in this branch.
-    Effect.map((value) => value));
+    Effect.map((value) => Fn.cast(value)));
 };
 const encodeToolExecutionModelContext = (tool, projection, modelResult) => {
     if (projection === undefined) {
         return Effect.succeed(undefined);
     }
-    return Schema.encodeUnknown(projection.schema)(modelResult).pipe(Effect.flatMap((encodedResult) => Schema.encodeUnknown(Schema.parseJson())({
+    return Schema.encodeUnknownEffect(projection.schema)(modelResult).pipe(Effect.flatMap((encodedResult) => Schema.encodeUnknownEffect(Schema.fromJsonString(Schema.Unknown))({
         tool,
         result: encodedResult,
-    })), Effect.flatMap((context) => Schema.decodeUnknown(ToolExecutionModelContextSchema)(context)), Effect.mapError(() => new InvalidToolProjection({
+    })), Effect.flatMap((context) => Schema.decodeUnknownEffect(ToolExecutionModelContextSchema)(context)), Effect.mapError(() => new InvalidToolProjection({
         tool,
         target: "model_context",
         reason: "invalid_model_result",
@@ -95,17 +111,28 @@ const projectViews = (tool, presenters, result) => Effect.forEach(presenters, (p
 }).pipe(Effect.map((parts) => parts.flatMap((part) => part === undefined ? [] : [part])), Effect.map((parts) => {
     // SAFETY: Every retained part was parsed by the corresponding presenter
     // view, and the output union is derived from that same presenter tuple.
-    return unsafeCoerce(parts);
+    return Fn.cast(parts);
 }));
+const makeModelInputSchema = (schema) => {
+    const document = JsonSchema.toDocumentDraft07(Schema.toJsonSchemaDocument(schema));
+    const definitions = Object.keys(document.definitions).length === 0
+        ? {}
+        : { definitions: document.definitions };
+    return {
+        $schema: JsonSchema.META_SCHEMA_URI_DRAFT_07,
+        ...document.schema,
+        ...definitions,
+    };
+};
 const makeTool = (runtime) => {
     // SAFETY: ToolRuntime.callSchema is constructed from this tool's exact
     // literal name and InputSchema before makeTool is called.
-    const callSchema = runtime.callSchema;
+    const callSchema = Fn.cast(runtime.callSchema);
     const parseCall = (input) => parseToolCall(runtime.name, callSchema, input);
     const executeRuntime = (input, context) => runtime.executeServer(input, 
     // SAFETY: command constructors expose a required context while query
     // constructors expose no context; runtime.operation owns that invariant.
-    unsafeCoerce(context)).pipe(Effect.flatMap((serverResult) => Effect.all({
+    Fn.cast(context)).pipe(Effect.flatMap((serverResult) => Effect.all({
         modelResult: projectModelResult(runtime.name, runtime.modelProjection, serverResult),
         views: projectViews(runtime.name, runtime.presenters, serverResult),
     }).pipe(Effect.flatMap(({ modelResult, views }) => encodeToolExecutionModelContext(runtime.name, runtime.modelProjection, modelResult).pipe(Effect.map((modelContext) => ({
@@ -118,7 +145,7 @@ const makeTool = (runtime) => {
     }));
     // SAFETY: command constructors expose a required context while query
     // constructors expose no context; both feed this operation-tagged runtime.
-    const execute = unsafeCoerce(executeRuntime);
+    const execute = Fn.cast(executeRuntime);
     const executeCallRuntime = (input, context) => parseCall(input).pipe(Effect.flatMap((call) => executeRuntime(call.arguments, context)));
     return structuredDefinition("tool")({
         _tag: "StructuredTool",
@@ -130,11 +157,11 @@ const makeTool = (runtime) => {
         model: {
             name: runtime.name,
             description: runtime.description,
-            inputSchema: JSONSchema.make(runtime.inputSchema),
+            inputSchema: makeModelInputSchema(runtime.inputSchema),
         },
         parseCall,
         execute,
-        executeCall: unsafeCoerce(executeCallRuntime),
+        executeCall: Fn.cast(executeCallRuntime),
         [toolRuntime]: runtime,
         pipe() {
             return Pipeable.pipeArguments(this, arguments);
@@ -153,7 +180,7 @@ export const defineTool = (definition) => {
     });
     // SAFETY: the literal name and input schema are exactly the two ToolCall
     // fields, and the constituent schemas require no runtime context.
-    const callSchema = unsafeCoerce(rawCallSchema);
+    const callSchema = Fn.cast(rawCallSchema);
     return makeTool({
         name,
         description,
@@ -174,7 +201,7 @@ export const defineCommand = (definition) => {
         arguments: definition.input,
     });
     // SAFETY: the literal name and input schema exactly form ToolCall.
-    const callSchema = unsafeCoerce(rawCallSchema);
+    const callSchema = Fn.cast(rawCallSchema);
     return makeTool({
         name: definition.name,
         description: definition.description,
@@ -195,7 +222,7 @@ const modelResult = (schema, project) => (tool) => {
     };
     // SAFETY: this combinator changes only the model-projection slot from
     // absent to the exact supplied schema and projector.
-    return makeTool(unsafeCoerce(nextRuntime));
+    return makeTool(Fn.cast(nextRuntime));
 };
 /** Add one optional display-safe view projection to a tool. */
 const present = (view, project) => (tool) => {

package/dist/core/view.d.ts

@@ -1,38 +1,47 @@
-import { Effect, Either, Schema } from "effect";
-import type * as ParseResult from "effect/ParseResult";
+import { Effect, Result, Schema } from "effect";
 import type { JsonValue } from "./json-value.js";
 /** Stable machine-facing name for one structured chat view. */
-export declare const ViewNameSchema: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
+export declare const ViewNameSchema: Schema.Trimmed;
 /** Positive protocol version for one structured chat view. */
-export declare const ViewVersionSchema: Schema.filter<Schema.filter<typeof Schema.Number>>;
+export declare const ViewVersionSchema: Schema.Number;
+/** Schema accepted at view boundaries without runtime services. */
+export type ViewSchema = Schema.Codec<unknown, unknown, never, never>;
+/** Schema for one decoded view part correlated with its view data. */
+export type ViewPartSchema<Name extends string = string, DataSchema extends ViewSchema = ViewSchema> = Schema.Codec<{
+    readonly type: "data";
+    readonly name: Name;
+    readonly data: Schema.Schema.Type<DataSchema>;
+}, unknown, never, never>;
 /** Minimum runtime shape retained for every structured chat view. */
-export interface ViewDefinitionContract<Name extends string = string, Version extends number = number, InputSchema extends Schema.Schema.AnyNoContext = Schema.Schema.AnyNoContext, DataSchema extends Schema.Schema.AnyNoContext = Schema.Schema.AnyNoContext, PartSchema extends Schema.Schema.AnyNoContext = Schema.Schema.AnyNoContext> {
+export interface ViewDefinitionContract<Name extends string = string, Version extends number = number, InputSchema extends ViewSchema = ViewSchema, DataSchema extends ViewSchema = ViewSchema, PartSchema extends ViewPartSchema<Name, DataSchema> = ViewPartSchema<Name, DataSchema>> {
     readonly name: Name;
     readonly version: Version;
     readonly inputSchema: InputSchema;
     readonly dataSchema: DataSchema;
     readonly partSchema: PartSchema;
     /** Parse unknown application data into one display-safe data part. */
-    readonly parseData: (input: JsonValue) => Effect.Effect<Schema.Schema.Type<PartSchema>, ParseResult.ParseError>;
+    parseData(input: ViewInput<this>): Effect.Effect<ViewPart<this>, Schema.SchemaError>;
     /** Parse an unknown serialized part without requiring an Effect runtime. */
-    readonly decodeEither: (input: JsonValue) => Either.Either<Schema.Schema.Type<PartSchema>, ParseResult.ParseError>;
+    decodeResult(input: JsonValue): Result.Result<ViewPart<this>, Schema.SchemaError>;
 }
 /** Parsed data accepted when constructing one view part. */
 export type ViewInput<View extends ViewDefinitionContract> = Schema.Schema.Type<View["inputSchema"]>;
 /** Versioned display data carried by one view part. */
 export type ViewData<View extends ViewDefinitionContract> = Schema.Schema.Type<View["dataSchema"]>;
 /** Complete structured message part produced by one view. */
-export type ViewPart<View extends ViewDefinitionContract> = Schema.Schema.Type<View["partSchema"]>;
+export type ViewPart<View extends ViewDefinitionContract> = Schema.Schema.Type<View["partSchema"]> & {
+    readonly data: ViewData<View>;
+};
 /** One schema-defined, versioned structured chat view. */
-export interface ViewDefinition<Name extends string, Version extends number, InputSchema extends Schema.Schema.AnyNoContext, DataSchema extends Schema.Schema.AnyNoContext, PartSchema extends Schema.Schema.AnyNoContext> extends ViewDefinitionContract<Name, Version, InputSchema, DataSchema, PartSchema> {
+export interface ViewDefinition<Name extends string, Version extends number, InputSchema extends ViewSchema, DataSchema extends ViewSchema, PartSchema extends ViewPartSchema<Name, DataSchema>> extends ViewDefinitionContract<Name, Version, InputSchema, DataSchema, PartSchema> {
     /** Construct and validate one display-safe data part. */
-    readonly make: (input: Schema.Schema.Type<InputSchema>) => Schema.Schema.Type<PartSchema>;
+    make(input: Schema.Schema.Type<InputSchema>): Schema.Schema.Type<PartSchema>;
     /** Parse unknown input into one display-safe data part. */
-    readonly parseData: (input: JsonValue) => Effect.Effect<Schema.Schema.Type<PartSchema>, ParseResult.ParseError>;
+    parseData(input: ViewInput<this>): Effect.Effect<ViewPart<this>, Schema.SchemaError>;
     /** Parse an unknown serialized part at a runtime boundary. */
-    readonly decode: (input: JsonValue) => Effect.Effect<Schema.Schema.Type<PartSchema>, ParseResult.ParseError>;
+    decode(input: JsonValue): Effect.Effect<ViewPart<this>, Schema.SchemaError>;
     /** Parse an unknown serialized part without requiring an Effect runtime. */
-    readonly decodeEither: (input: JsonValue) => Either.Either<Schema.Schema.Type<PartSchema>, ParseResult.ParseError>;
+    decodeResult(input: JsonValue): Result.Result<ViewPart<this>, Schema.SchemaError>;
 }
 /** Definition input for one versioned structured chat view. */
 export interface DefineViewInput<Name extends string, Version extends number, Fields extends Schema.Struct.Fields> {
@@ -41,7 +50,7 @@ export interface DefineViewInput<Name extends string, Version extends number, Fi
     readonly schema: Schema.Struct<Fields>;
 }
 type NoContextFields<Fields extends Schema.Struct.Fields> = [
-    Schema.Struct.Context<Fields>
+    Schema.Struct.DecodingServices<Fields> | Schema.Struct.EncodingServices<Fields>
 ] extends [never] ? unknown : never;
 /**
  * Define one typed server-to-browser view contract.
@@ -54,42 +63,58 @@ export declare const defineView: <const Name extends string, const Version exten
     version: Version;
     inputSchema: Schema.Struct<Fields>;
     dataSchema: Schema.Struct<{
-        readonly schemaVersion: Schema.Literal<[Version]>;
+        readonly schemaVersion: Schema.Literal<Version>;
     } & Fields>;
     partSchema: Schema.Struct<{
-        readonly type: Schema.Literal<["data"]>;
-        readonly name: Schema.Literal<[Name]>;
+        readonly type: Schema.Literal<"data">;
+        readonly name: Schema.Literal<Name>;
         readonly data: Schema.Struct<{
-            readonly schemaVersion: Schema.Literal<[Version]>;
+            readonly schemaVersion: Schema.Literal<Version>;
         } & Fields>;
     }>;
-    make: (input: Schema.Struct.Type<Fields> extends infer T ? { [K in keyof T]: T[K]; } : never) => {
-        readonly name: Name;
+    make: (input: Schema.Struct.View<Fields, "Type", Schema.Struct.TypeOptionalKeys<Fields>, Schema.Struct.TypeMutableKeys<Fields>>) => {
         readonly type: "data";
-        readonly data: Schema.Struct.Type<{
-            readonly schemaVersion: Schema.Literal<[Version]>;
-        } & Fields> extends infer T_1 ? { [K_1 in keyof T_1]: T_1[K_1]; } : never;
-    };
-    parseData: (input: JsonValue) => Effect.Effect<{
         readonly name: Name;
+        readonly data: Schema.Struct.View<{
+            readonly schemaVersion: Schema.Literal<Version>;
+        } & Fields, "Type", Schema.Struct.TypeOptionalKeys<{
+            readonly schemaVersion: Schema.Literal<Version>;
+        } & Fields>, Schema.Struct.TypeMutableKeys<{
+            readonly schemaVersion: Schema.Literal<Version>;
+        } & Fields>>;
+    };
+    parseData: (input: Schema.Struct.View<Fields, "Type", Schema.Struct.TypeOptionalKeys<Fields>, Schema.Struct.TypeMutableKeys<Fields>>) => Effect.Effect<{
         readonly type: "data";
-        readonly data: Schema.Struct.Type<{
-            readonly schemaVersion: Schema.Literal<[Version]>;
-        } & Fields> extends infer T ? { [K in keyof T]: T[K]; } : never;
-    }, ParseResult.ParseError>;
-    decode: (input: JsonValue) => Effect.Effect<{
         readonly name: Name;
+        readonly data: Schema.Struct.View<{
+            readonly schemaVersion: Schema.Literal<Version>;
+        } & Fields, "Type", Schema.Struct.TypeOptionalKeys<{
+            readonly schemaVersion: Schema.Literal<Version>;
+        } & Fields>, Schema.Struct.TypeMutableKeys<{
+            readonly schemaVersion: Schema.Literal<Version>;
+        } & Fields>>;
+    }, Schema.SchemaError>;
+    decode: (input: JsonValue) => Effect.Effect<{
         readonly type: "data";
-        readonly data: Schema.Struct.Type<{
-            readonly schemaVersion: Schema.Literal<[Version]>;
-        } & Fields> extends infer T ? { [K in keyof T]: T[K]; } : never;
-    }, ParseResult.ParseError, never>;
-    decodeEither: (input: JsonValue) => Either.Either<{
         readonly name: Name;
+        readonly data: Schema.Struct.View<{
+            readonly schemaVersion: Schema.Literal<Version>;
+        } & Fields, "Type", Schema.Struct.TypeOptionalKeys<{
+            readonly schemaVersion: Schema.Literal<Version>;
+        } & Fields>, Schema.Struct.TypeMutableKeys<{
+            readonly schemaVersion: Schema.Literal<Version>;
+        } & Fields>>;
+    }, Schema.SchemaError, never>;
+    decodeResult: (input: JsonValue) => Result.Result<{
         readonly type: "data";
-        readonly data: Schema.Struct.Type<{
-            readonly schemaVersion: Schema.Literal<[Version]>;
-        } & Fields> extends infer T ? { [K in keyof T]: T[K]; } : never;
-    }, ParseResult.ParseError>;
+        readonly name: Name;
+        readonly data: Schema.Struct.View<{
+            readonly schemaVersion: Schema.Literal<Version>;
+        } & Fields, "Type", Schema.Struct.TypeOptionalKeys<{
+            readonly schemaVersion: Schema.Literal<Version>;
+        } & Fields>, Schema.Struct.TypeMutableKeys<{
+            readonly schemaVersion: Schema.Literal<Version>;
+        } & Fields>>;
+    }, Schema.SchemaError>;
 };
 export {};

package/dist/core/view.js

@@ -1,8 +1,8 @@
-import { Effect, Either, Schema, unsafeCoerce } from "effect";
+import { Effect, Function as Fn, Result, Schema } from "effect";
 /** Stable machine-facing name for one structured chat view. */
-export const ViewNameSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(100), Schema.pattern(/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/));
+export const ViewNameSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(100), Schema.isPattern(/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/));
 /** Positive protocol version for one structured chat view. */
-export const ViewVersionSchema = Schema.Number.pipe(Schema.int(), Schema.between(1, 2_147_483_647));
+export const ViewVersionSchema = Schema.Number.check(Schema.isInt(), Schema.isBetween({ minimum: 1, maximum: 2_147_483_647 }));
 /**
  * Define one typed server-to-browser view contract.
  *
@@ -15,14 +15,10 @@ export const defineView = (definition) => {
     if ("schemaVersion" in definition.schema.fields) {
         throw new Error("View schemas cannot define the reserved schemaVersion field");
     }
-    // SAFETY: the reserved schemaVersion field cannot be supplied by Fields;
-    // the literal therefore augments the exact application schema once.
     const dataSchema = Schema.Struct({
         schemaVersion: Schema.Literal(definition.version),
         ...definition.schema.fields,
     });
-    // SAFETY: these literals and dataSchema exactly describe ViewPart<Name,
-    // Version, Fields>; the assertions retain that generic correlation.
     const partSchema = Schema.Struct({
         type: Schema.Literal("data"),
         name: Schema.Literal(definition.name),
@@ -30,14 +26,15 @@ export const defineView = (definition) => {
     });
     // SAFETY: NoContextFields excludes schemas with runtime requirements; this
     // assertion preserves definition.schema's existing Type and Encoded sides.
-    const runtimeInputSchema = unsafeCoerce(definition.schema);
+    const runtimeInputSchema = Fn.cast(definition.schema);
     // SAFETY: partSchema was built immediately above from the exact view name,
     // version, and application fields, with no runtime schema requirements.
-    const runtimePartSchema = unsafeCoerce(partSchema);
-    const decodePart = Schema.decodeUnknown(runtimePartSchema);
-    const decodePartEither = Schema.decodeUnknownEither(runtimePartSchema);
-    const validatePart = Schema.validate(runtimePartSchema);
-    const parseData = (input) => Schema.validate(runtimeInputSchema)(input, {
+    const runtimePartSchema = Fn.cast(partSchema);
+    const decodePart = Schema.decodeUnknownEffect(runtimePartSchema);
+    const decodePartResult = Schema.decodeUnknownResult(runtimePartSchema);
+    const validateInput = Schema.decodeUnknownEffect(Schema.toType(runtimeInputSchema));
+    const validatePart = Schema.decodeUnknownEffect(Schema.toType(runtimePartSchema));
+    const parseData = (input) => validateInput(input, {
         onExcessProperty: "error",
     }).pipe(Effect.flatMap((data) => validatePart({
         type: "data",
@@ -47,7 +44,7 @@ export const defineView = (definition) => {
             ...data,
         },
     }, { onExcessProperty: "error" })));
-    const make = (input) => Schema.validateSync(runtimePartSchema)({
+    const make = (input) => Schema.decodeUnknownSync(Schema.toType(runtimePartSchema))({
         type: "data",
         name: definition.name,
         data: {
@@ -64,6 +61,6 @@ export const defineView = (definition) => {
         make,
         parseData,
         decode: (input) => decodePart(input, { onExcessProperty: "error" }),
-        decodeEither: (input) => decodePartEither(input, { onExcessProperty: "error" }),
+        decodeResult: (input) => decodePartResult(input, { onExcessProperty: "error" }),
     };
 };

package/dist/integrations/assistant-ui.js

@@ -1,7 +1,8 @@
 import { makeAssistantDataUI, } from "@assistant-ui/core/react";
-import { Either, Schema } from "effect";
+import { Exit, Result, Schema } from "effect";
 import { createElement } from "react";
 import { StructuredChatSessionReferenceSchema, StructuredChatTurnRequestSchema, StructuredChatTurnResponseSchema, } from "../core/protocol.js";
+import { JsonValueSchema } from "../core/json-value.js";
 /**
  * Register one defineView contract as a strictly decoded assistant-ui data UI.
  *
@@ -10,19 +11,25 @@ import { StructuredChatSessionReferenceSchema, StructuredChatTurnRequestSchema,
  */
 export const makeAssistantView = (view, config) => {
     const Renderer = (props) => {
-        const decoded = Schema.decodeUnknownEither(view.partSchema)({
+        const data = Schema.decodeUnknownResult(JsonValueSchema)(props.data);
+        if (Result.isFailure(data)) {
+            return config.fallback === undefined
+                ? null
+                : createElement(config.fallback, props);
+        }
+        const decoded = view.decodeResult({
             type: "data",
             name: view.name,
-            data: props.data,
-        }, { onExcessProperty: "error" });
-        if (Either.isLeft(decoded)) {
+            data: data.success,
+        });
+        if (Result.isFailure(decoded)) {
             return config.fallback === undefined
                 ? null
                 : createElement(config.fallback, props);
         }
         return createElement(config.render, {
             ...props,
-            data: decoded.right.data,
+            data: decoded.success.data,
         });
     };
     return makeAssistantDataUI({
@@ -42,9 +49,9 @@ const readLatestSession = (messages) => {
         if (message?.role !== "assistant") {
             continue;
         }
-        const session = Schema.decodeUnknownEither(StructuredChatSessionReferenceSchema)(message.metadata.custom[assistantChatSessionMetadataKey]);
-        if (Either.isRight(session)) {
-            return session.right;
+        const session = Schema.decodeUnknownExit(StructuredChatSessionReferenceSchema)(message.metadata.custom[assistantChatSessionMetadataKey]);
+        if (Exit.isSuccess(session)) {
+            return session.value;
         }
     }
     return undefined;
@@ -95,17 +102,17 @@ export const makeAssistantChatModelAdapter = (options) => {
             catch {
                 throw new Error("Structured chat returned an invalid response");
             }
-            const decoded = Schema.decodeUnknownEither(StructuredChatTurnResponseSchema)(body, { onExcessProperty: "error" });
-            if (Either.isLeft(decoded)) {
+            const decoded = Schema.decodeUnknownExit(StructuredChatTurnResponseSchema)(body, { onExcessProperty: "error" });
+            if (Exit.isFailure(decoded)) {
                 throw new Error("Structured chat returned an invalid response");
             }
             return {
-                content: decoded.right.message.content,
+                content: decoded.value.message.content,
                 metadata: {
-                    custom: decoded.right.session === undefined
+                    custom: decoded.value.session === undefined
                         ? {}
                         : {
-                            [assistantChatSessionMetadataKey]: decoded.right.session,
+                            [assistantChatSessionMetadataKey]: decoded.value.session,
                         },
                 },
             };

package/dist/testing/in-memory-session-store.js

@@ -30,7 +30,7 @@ const replaceSnapshot = (sessions, input) => {
     return [snapshot, next];
 };
 /** In-memory optimistic session store intended for tests and examples. */
-export const inMemoryChatSessionStore = Layer.effect(ChatSessionStore, Ref.make(new Map()).pipe(Effect.map((sessions) => ({
+export const inMemoryChatSessionStore = Layer.effect(ChatSessionStore, Ref.make(new Map()).pipe(Effect.map((sessions) => ChatSessionStore.of({
     load: (scope) => Ref.get(sessions).pipe(Effect.map((current) => current.get(scopeKey(scope)) ?? null)),
     replace: (input) => Ref.modify(sessions, (current) => replaceSnapshot(current, input)).pipe(Effect.flatMap((result) => result instanceof ChatSessionConflict
         ? Effect.fail(result)

package/dist/testing/scenario.js

@@ -2,7 +2,7 @@ import { Effect, Layer, Ref, Schema } from "effect";
 import { StructuredChatModel, } from "../core/model.js";
 import { JsonValueSchema, } from "../core/json-value.js";
 const scenarioQuote = Symbol("@popcomputer/structured-chat/testing/ScenarioQuote");
-const ScenarioQuoteSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(2_000));
+const ScenarioQuoteSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(2_000));
 const evidenceIndex = (request, quoted) => {
     if (quoted.messageIndex !== undefined) {
         const message = request.untrustedMessages[quoted.messageIndex];
@@ -49,7 +49,7 @@ const answers = (stage, proposed, options = {}) => ({
             if (value === undefined || answer === undefined) {
                 continue;
             }
-            encodedAnswers[field] = Schema.decodeSync(JsonValueSchema)(Schema.encodeSync(answer.schema)(value.value));
+            encodedAnswers[field] = Schema.decodeUnknownSync(JsonValueSchema)(Schema.encodeSync(answer.schema)(value.value));
             evidenceIndex(request, value);
             evidence.push({
                 field,
@@ -76,7 +76,7 @@ const answers = (stage, proposed, options = {}) => ({
 const call = (tool, input) => ({
     respond: () => ({
         name: tool.name,
-        arguments: Schema.decodeSync(JsonValueSchema)(Schema.encodeSync(tool.inputSchema)(input)),
+        arguments: Schema.decodeUnknownSync(JsonValueSchema)(Schema.encodeSync(tool.inputSchema)(input)),
     }),
 });
 const replace = (stage, field, value, options) => {
@@ -92,7 +92,7 @@ const replace = (stage, field, value, options) => {
                 _tag: "ReplaceAcceptedAnswer",
                 stage: stage.name,
                 field,
-                value: Schema.decodeSync(JsonValueSchema)(Schema.encodeSync(answer.schema)(value)),
+                value: Schema.decodeUnknownSync(JsonValueSchema)(Schema.encodeSync(answer.schema)(value)),
                 evidence: {
                     quote: support.quote,
                 },
@@ -126,14 +126,14 @@ const repairs = (first, ...remaining) => ({
 });
 const model = (first, ...remaining) => Layer.effect(StructuredChatModel, Ref.make(0).pipe(Effect.map((cursor) => {
     const steps = [first, ...remaining];
-    return {
+    return StructuredChatModel.of({
         requestTool: (request) => Ref.getAndUpdate(cursor, (index) => index + 1).pipe(Effect.flatMap((index) => {
             const step = steps[index];
             return step === undefined
                 ? Effect.die(new Error(`Scenario model exhausted after ${steps.length} requests`))
                 : Effect.sync(() => step.respond(request));
         })),
-    };
+    });
 })));
 /** Typed constructors for concise valid transcript scenarios. */
 export const Scenario = {