@popcomputer/structured-chat 0.1.0 → 0.2.0

package/dist/core/stage.js

@@ -1,4 +1,4 @@
-import { Effect, Schema, unsafeCoerce } from "effect";
+import { Effect, Function as Fn, Schema } from "effect";
 import { Instruction, planToolCall, StructuredChatModel, } from "./model.js";
 import { defineToolSet, } from "./tool-set.js";
 import { defineCollectStage } from "./collect-stage.js";
@@ -6,7 +6,10 @@ import { StageNameSchema } from "./stage-name.js";
 import { structuredDefinition, } from "./definition.js";
 export { StageNameSchema } from "./stage-name.js";
 /** State transition applied after one tool-stage execution. */
-export const ToolStageAfterExecutionSchema = Schema.Literal("stay", "complete");
+export const ToolStageAfterExecutionSchema = Schema.Literals([
+    "stay",
+    "complete",
+]);
 const toolStageRuntime = Symbol("@popcomputer/structured-chat/ToolStageRuntime");
 /** @internal Read the erased runtime from an authentic tool stage. */
 export const readToolStageRuntime = (stage) => stage[toolStageRuntime];
@@ -19,7 +22,7 @@ const defineToolStage = (definition) => {
     const toolSet = defineToolSet(...definition.tools);
     // 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 ?? Fn.cast([]);
     const afterExecution = Schema.decodeSync(ToolStageAfterExecutionSchema)(definition.afterExecution ?? "stay");
     const plan = (messages) => planToolCall({
         instructions,
@@ -32,7 +35,7 @@ const defineToolStage = (definition) => {
     const run = (messages) => plan(messages).pipe(Effect.flatMap(toolSet.execute));
     // SAFETY: chat repair supplies only a call parsed by a combined set that
     // contains this exact query tuple; non-repair names therefore belong here.
-    const executeRuntime = toolSet.execute;
+    const executeRuntime = Fn.cast(toolSet.execute);
     const planWith = (messages, additionalTool) => {
         // SAFETY: the additional package-owned query and this non-empty exact
         // query tuple form another valid closed tool set for planning only.
@@ -65,24 +68,24 @@ const defineCommandStage = (definition) => {
     Schema.decodeSync(StageNameSchema)(definition.name);
     const instructions = definition.instructions.map(Instruction.make);
     // SAFETY: when omitted, Guards is its readonly [] default.
-    const guards = definition.guards ?? unsafeCoerce([]);
+    const guards = definition.guards ?? Fn.cast([]);
     const planner = {
         models: [definition.command.model],
         // SAFETY: this command parses its literal name and exact input schema.
-        parseCall: definition.command.parseCall,
+        parseCall: Fn.cast(definition.command.parseCall),
     };
     const plan = (messages) => planToolCall({ instructions, messages, tools: planner, guards }).pipe(Effect.withSpan("popcomputer.structured_chat.command_stage.plan", {
         attributes: { stage: definition.name },
     }));
     // SAFETY: Command has the package-owned identity and command operation;
     // its parsed call and runtime execute input originate from one definition.
-    const runtimeCommand = unsafeCoerce(definition.command);
+    const runtimeCommand = Fn.cast(definition.command);
     const runRuntime = (messages, context) => plan(messages).pipe(Effect.flatMap((call) => runtimeCommand.execute(call.arguments, context)), Effect.withSpan("popcomputer.structured_chat.command_stage.run", {
         attributes: { stage: definition.name },
     }));
     // SAFETY: failures and requirements are not recovered; the command's
     // projections and result are preserved by its own execute operation.
-    const run = runRuntime;
+    const run = Fn.cast(runRuntime);
     return structuredDefinition("command_stage")({
         _tag: "CommandStage",
         name: definition.name,

package/dist/core/tool-set.js

@@ -1,4 +1,4 @@
-import { Effect, Schema, unsafeCoerce } from "effect";
+import { Effect, Function as Fn, Schema } from "effect";
 import { InvalidToolCall as InvalidToolCallError, InvalidToolCallReasonSchema, ToolNameSchema, } from "./tool.js";
 import { JsonValueSchema } from "./json-value.js";
 const IncomingToolCallSchema = Schema.Struct({
@@ -28,7 +28,7 @@ export const defineToolSet = (...tools) => {
         // SAFETY: ToolDefinitionContract carries the package-owned nominal identity.
         // Runtime execution is erased here and restored by ToolSet's conditional
         // public result, error, and requirement types.
-        runtimeTools.set(tool.name, unsafeCoerce(tool));
+        runtimeTools.set(tool.name, Fn.cast(tool));
     }
     const selectTool = (name) => {
         const tool = runtimeTools.get(name);
@@ -37,21 +37,21 @@ export const defineToolSet = (...tools) => {
         }
         return Effect.succeed(tool);
     };
-    const parseCallRuntime = (input) => Schema.decodeUnknown(IncomingToolCallSchema)(input, {
+    const parseCallRuntime = (input) => Schema.decodeUnknownEffect(IncomingToolCallSchema)(input, {
         onExcessProperty: "error",
     }).pipe(Effect.mapError(() => invalidCall("invalid_envelope", null)), Effect.flatMap((call) => selectTool(call.name).pipe(Effect.flatMap((tool) => tool.parseCall(call)))), Effect.withSpan("popcomputer.structured_chat.tool_set.parse", {
         attributes: { toolCount: tools.length },
     }));
     // SAFETY: the envelope parser establishes a registered name, then that
     // registered tool parses its own literal name and argument schema.
-    const parseCall = parseCallRuntime;
+    const parseCall = Fn.cast(parseCallRuntime);
     const executeRuntime = (call) => selectTool(call.name).pipe(Effect.flatMap((tool) => tool.execute(call.arguments)), Effect.withSpan("popcomputer.structured_chat.tool_set.execute", {
         attributes: { toolCount: tools.length },
     }));
     // SAFETY: call is a parsed member of ToolSetCall<Tools>; dispatch selects
     // that member's registered runtime and passes its decoded arguments to the
     // corresponding Type-side execute operation.
-    const execute = executeRuntime;
+    const execute = Fn.cast(executeRuntime);
     const executeCall = (input) => parseCall(input).pipe(Effect.flatMap(execute));
     return {
         tools,
@@ -61,6 +61,6 @@ export const defineToolSet = (...tools) => {
         // SAFETY: dispatch selects a member of Tools by its unique runtime name.
         // Each tool parses itself before executing, so the resulting union exactly
         // matches ToolSetExecution, ToolSetError, and ToolSetRequirements.
-        executeCall: executeCall,
+        executeCall: Fn.cast(executeCall),
     };
 };

package/dist/core/tool.d.ts

@@ -1,34 +1,29 @@
-import { Effect, JSONSchema, Pipeable, Schema } from "effect";
-import * as ParseResult from "effect/ParseResult";
+import { Effect, JsonSchema, Pipeable, Schema } from "effect";
 import type { ViewDefinitionContract, ViewInput, ViewPart } from "./view.js";
 import { type StructuredDefinition } from "./definition.js";
 import type { CommandId } from "./command.js";
 import type { JsonValue } from "./json-value.js";
 /** Stable machine-facing name for one structured chat tool. */
-export declare const ToolNameSchema: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
+export declare const ToolNameSchema: Schema.Trimmed;
 /** Bounded model-facing description for one structured chat tool. */
-export declare const ToolDescriptionSchema: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
+export declare const ToolDescriptionSchema: Schema.Trimmed;
 /** Safe reason that a model-authored tool call was rejected. */
-export declare const InvalidToolCallReasonSchema: Schema.Literal<["invalid_envelope", "unknown_tool", "invalid_arguments"]>;
-declare const InvalidToolCall_base: Schema.TaggedErrorClass<InvalidToolCall, "InvalidToolCall", {
-    readonly _tag: Schema.tag<"InvalidToolCall">;
-} & {
-    tool: Schema.NullOr<Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>>;
-    reason: Schema.Literal<["invalid_envelope", "unknown_tool", "invalid_arguments"]>;
-    path: Schema.NullOr<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
-}>;
+export declare const InvalidToolCallReasonSchema: Schema.Literals<readonly ["invalid_envelope", "unknown_tool", "invalid_arguments"]>;
+declare const InvalidToolCall_base: Schema.Class<InvalidToolCall, Schema.TaggedStruct<"InvalidToolCall", {
+    readonly tool: Schema.NullOr<Schema.Trimmed>;
+    readonly reason: Schema.Literals<readonly ["invalid_envelope", "unknown_tool", "invalid_arguments"]>;
+    readonly path: Schema.NullOr<Schema.Trimmed>;
+}>, import("effect/Cause").YieldableError>;
 /** A model-authored tool call failed strict parsing. */
 export declare class InvalidToolCall extends InvalidToolCall_base {
 }
 /** Safe reason that an application-owned tool projection was rejected. */
-export declare const InvalidToolProjectionReasonSchema: Schema.Literal<["invalid_model_result", "invalid_view_data"]>;
-declare const InvalidToolProjection_base: Schema.TaggedErrorClass<InvalidToolProjection, "InvalidToolProjection", {
-    readonly _tag: Schema.tag<"InvalidToolProjection">;
-} & {
-    tool: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
-    target: typeof Schema.String;
-    reason: Schema.Literal<["invalid_model_result", "invalid_view_data"]>;
-}>;
+export declare const InvalidToolProjectionReasonSchema: Schema.Literals<readonly ["invalid_model_result", "invalid_view_data"]>;
+declare const InvalidToolProjection_base: Schema.Class<InvalidToolProjection, Schema.TaggedStruct<"InvalidToolProjection", {
+    readonly tool: Schema.Trimmed;
+    readonly target: Schema.String;
+    readonly reason: Schema.Literals<readonly ["invalid_model_result", "invalid_view_data"]>;
+}>, import("effect/Cause").YieldableError>;
 /** An application-owned model or view projection violated its schema. */
 export declare class InvalidToolProjection extends InvalidToolProjection_base {
 }
@@ -36,8 +31,10 @@ export declare class InvalidToolProjection extends InvalidToolProjection_base {
 export interface ModelToolDefinition<Name extends string = string> {
     readonly name: Name;
     readonly description: string;
-    readonly inputSchema: JSONSchema.JsonSchema7Root;
+    readonly inputSchema: JsonSchema.JsonSchema;
 }
+/** Schema accepted at tool boundaries without runtime services. */
+export type ToolSchema = Schema.Codec<unknown, unknown, never, never>;
 /** Whether an executable model capability is repeatable or side-effecting. */
 export type ToolOperation = "query" | "command";
 /** Opaque stable identity supplied when a command executes. */
@@ -50,7 +47,7 @@ export interface ToolDefinitionContract extends StructuredDefinition<"tool"> {
     readonly operation: ToolOperation;
     readonly name: string;
     readonly description: string;
-    readonly inputSchema: Schema.Schema.AnyNoContext;
+    readonly inputSchema: ToolSchema;
     readonly model: ModelToolDefinition;
 }
 /** Minimum runtime shape retained for a repeatable read-only query. */
@@ -60,10 +57,10 @@ export interface QueryToolDefinitionContract extends ToolDefinitionContract {
 /** Minimum runtime shape retained for a side-effecting command. */
 export interface CommandDefinitionContract extends ToolDefinitionContract {
     readonly operation: "command";
-    readonly parseCall: (input: JsonValue) => Effect.Effect<ToolCall<string, Schema.Schema.AnyNoContext>, InvalidToolCall>;
+    readonly parseCall: (input: JsonValue) => Effect.Effect<ToolCall<string, ToolSchema>, InvalidToolCall>;
 }
 /** One model-authored, schema-parsed tool call. */
-export type ToolCall<Name extends string, InputSchema extends Schema.Schema.AnyNoContext> = {
+export type ToolCall<Name extends string, InputSchema extends ToolSchema> = {
     readonly name: Name;
     readonly arguments: Schema.Schema.Type<InputSchema>;
 };
@@ -75,23 +72,23 @@ export interface ToolPresenter<ServerResult, View extends ViewDefinitionContract
 type PresenterView<Presenter> = Presenter extends ToolPresenter<infer _ServerResult, infer View> ? View : never;
 /** View-part union produced by one configured tool. */
 export type ToolViewPart<Presenters extends ReadonlyArray<ToolPresenter<never, ViewDefinitionContract>>> = ViewPart<PresenterView<Presenters[number]>>;
-type ToolModelResult<ModelSchema extends Schema.Schema.AnyNoContext | undefined> = ModelSchema extends Schema.Schema.AnyNoContext ? Schema.Schema.Type<ModelSchema> : undefined;
+type ToolModelResult<ModelSchema extends ToolSchema | undefined> = ModelSchema extends ToolSchema ? Schema.Schema.Type<ModelSchema> : undefined;
 /** Complete trusted result of one parsed and executed tool call. */
-export interface ToolExecution<ServerResult, ModelSchema extends Schema.Schema.AnyNoContext | undefined, Presenters extends ReadonlyArray<ToolPresenter<ServerResult, ViewDefinitionContract>>> {
+export interface ToolExecution<ServerResult, ModelSchema extends ToolSchema | undefined, Presenters extends ReadonlyArray<ToolPresenter<ServerResult, ViewDefinitionContract>>> {
     readonly serverResult: ServerResult;
     readonly modelResult: ToolModelResult<ModelSchema>;
     readonly views: ReadonlyArray<ToolViewPart<Presenters>>;
     readonly [toolExecutionModelContext]: string | undefined;
 }
-interface ToolModelProjection<ServerResult, ModelSchema extends Schema.Schema.AnyNoContext> {
+interface ToolModelProjection<ServerResult, ModelSchema extends ToolSchema> {
     readonly schema: ModelSchema;
     readonly project: (result: ServerResult) => Schema.Schema.Type<ModelSchema>;
 }
-interface ToolRuntime<Name extends string, InputSchema extends Schema.Schema.AnyNoContext, ServerResult, Error, Requirements, ModelSchema extends Schema.Schema.AnyNoContext | undefined, Presenters extends ReadonlyArray<ToolPresenter<ServerResult, ViewDefinitionContract>>, Operation extends ToolOperation> {
+interface ToolRuntime<Name extends string, InputSchema extends ToolSchema, ServerResult, Error, Requirements, ModelSchema extends ToolSchema | undefined, Presenters extends ReadonlyArray<ToolPresenter<ServerResult, ViewDefinitionContract>>, Operation extends ToolOperation> {
     readonly executeServer: (input: Schema.Schema.Type<InputSchema>, context: Operation extends "command" ? CommandExecutionContext : undefined) => Effect.Effect<ServerResult, Error, Requirements>;
-    readonly modelProjection: ModelSchema extends Schema.Schema.AnyNoContext ? ToolModelProjection<ServerResult, ModelSchema> : undefined;
+    readonly modelProjection: ModelSchema extends ToolSchema ? ToolModelProjection<ServerResult, ModelSchema> : undefined;
     readonly presenters: Presenters;
-    readonly callSchema: Schema.Schema.AnyNoContext;
+    readonly callSchema: ToolSchema;
     readonly name: Name;
     readonly description: string;
     readonly inputSchema: InputSchema;
@@ -105,7 +102,7 @@ interface RuntimeToolExecutionContext {
 /** @internal Read the bounded model-visible context retained by one execution. */
 export declare const readToolExecutionModelContext: (execution: RuntimeToolExecutionContext) => string | undefined;
 /** One schema-defined, executable, and pipeable query tool. */
-export interface StructuredTool<Name extends string, InputSchema extends Schema.Schema.AnyNoContext, ServerResult, Error, Requirements, ModelSchema extends Schema.Schema.AnyNoContext | undefined = undefined, Presenters extends ReadonlyArray<ToolPresenter<ServerResult, ViewDefinitionContract>> = readonly [], Operation extends ToolOperation = "query"> extends Pipeable.Pipeable, ToolDefinitionContract {
+export interface StructuredTool<Name extends string, InputSchema extends ToolSchema, ServerResult, Error, Requirements, ModelSchema extends ToolSchema | undefined = undefined, Presenters extends ReadonlyArray<ToolPresenter<ServerResult, ViewDefinitionContract>> = readonly [], Operation extends ToolOperation = "query"> extends Pipeable.Pipeable, ToolDefinitionContract {
     readonly name: Name;
     readonly operation: Operation;
     readonly inputSchema: InputSchema;
@@ -120,30 +117,30 @@ export interface StructuredTool<Name extends string, InputSchema extends Schema.
     readonly [toolRuntime]: ToolRuntime<Name, InputSchema, ServerResult, Error, Requirements, ModelSchema, Presenters, Operation>;
 }
 /** One side-effecting capability accepted only by a terminal command stage. */
-export type StructuredCommand<Name extends string, InputSchema extends Schema.Schema.AnyNoContext, ServerResult, Error, Requirements, ModelSchema extends Schema.Schema.AnyNoContext | undefined = undefined, Presenters extends ReadonlyArray<ToolPresenter<ServerResult, ViewDefinitionContract>> = readonly []> = StructuredTool<Name, InputSchema, ServerResult, Error, Requirements, ModelSchema, Presenters, "command">;
+export type StructuredCommand<Name extends string, InputSchema extends ToolSchema, ServerResult, Error, Requirements, ModelSchema extends ToolSchema | undefined = undefined, Presenters extends ReadonlyArray<ToolPresenter<ServerResult, ViewDefinitionContract>> = readonly []> = StructuredTool<Name, InputSchema, ServerResult, Error, Requirements, ModelSchema, Presenters, "command">;
 /** Definition input for one read-only structured chat tool. */
-export interface DefineToolInput<Name extends string, InputSchema extends Schema.Schema.AnyNoContext, ServerResult, Error, Requirements> {
+export interface DefineToolInput<Name extends string, InputSchema extends ToolSchema, ServerResult, Error, Requirements> {
     readonly name: Name;
     readonly description: string;
     readonly input: InputSchema;
     readonly execute: (input: Schema.Schema.Type<InputSchema>) => Effect.Effect<ServerResult, Error, Requirements>;
 }
 /** Definition input for one idempotently executed structured command. */
-export interface DefineCommandInput<Name extends string, InputSchema extends Schema.Schema.AnyNoContext, ServerResult, Error, Requirements> {
+export interface DefineCommandInput<Name extends string, InputSchema extends ToolSchema, ServerResult, Error, Requirements> {
     readonly name: Name;
     readonly description: string;
     readonly input: InputSchema;
     readonly execute: (input: Schema.Schema.Type<InputSchema>, context: CommandExecutionContext) => Effect.Effect<ServerResult, Error, Requirements>;
 }
 /** Define one read-only, schema-validated structured chat tool. */
-export declare const defineTool: <const Name extends string, InputSchema extends Schema.Schema.AnyNoContext, ServerResult, Error, Requirements>(definition: DefineToolInput<Name, InputSchema, ServerResult, Error, Requirements>) => StructuredTool<Name, InputSchema, ServerResult, Error, Requirements>;
+export declare const defineTool: <const Name extends string, InputSchema extends ToolSchema, ServerResult, Error, Requirements>(definition: DefineToolInput<Name, InputSchema, ServerResult, Error, Requirements>) => StructuredTool<Name, InputSchema, ServerResult, Error, Requirements>;
 /** Define one side-effecting command requiring a stable idempotency key. */
-export declare const defineCommand: <const Name extends string, InputSchema extends Schema.Schema.AnyNoContext, ServerResult, Error, Requirements>(definition: DefineCommandInput<Name, InputSchema, ServerResult, Error, Requirements>) => StructuredCommand<Name, InputSchema, ServerResult, Error, Requirements>;
+export declare const defineCommand: <const Name extends string, InputSchema extends ToolSchema, ServerResult, Error, Requirements>(definition: DefineCommandInput<Name, InputSchema, ServerResult, Error, Requirements>) => StructuredCommand<Name, InputSchema, ServerResult, Error, Requirements>;
 /** Combinators that add optional capabilities to a structured tool. */
 export declare const Tool: {
-    readonly modelResult: <ServerResult, ModelSchema extends Schema.Schema.AnyNoContext>(schema: ModelSchema, project: (result: ServerResult) => Schema.Schema.Type<ModelSchema>) => <Name extends string, InputSchema extends Schema.Schema.AnyNoContext, Error, Requirements, Presenters extends ReadonlyArray<ToolPresenter<ServerResult, ViewDefinitionContract>>, Operation extends ToolOperation>(tool: StructuredTool<Name, InputSchema, ServerResult, Error, Requirements, undefined, Presenters, Operation>) => StructuredTool<Name, InputSchema, ServerResult, Error, Requirements, ModelSchema, Presenters, Operation>;
-    readonly present: <ServerResult, View extends ViewDefinitionContract>(view: View, project: (result: ServerResult) => ViewInput<View> | undefined) => <Name extends string, InputSchema extends Schema.Schema.AnyNoContext, Error, Requirements, ModelSchema extends Schema.Schema.AnyNoContext | undefined, Presenters extends ReadonlyArray<ToolPresenter<ServerResult, ViewDefinitionContract>>, Operation extends ToolOperation>(tool: StructuredTool<Name, InputSchema, ServerResult, Error, Requirements, ModelSchema, Presenters, Operation>) => StructuredTool<Name, InputSchema, ServerResult, Error, Requirements, ModelSchema, readonly [...Presenters, ToolPresenter<ServerResult, View>], Operation>;
+    readonly modelResult: <ServerResult, ModelSchema extends ToolSchema>(schema: ModelSchema, project: (result: ServerResult) => Schema.Schema.Type<ModelSchema>) => <Name extends string, InputSchema extends ToolSchema, Error, Requirements, Presenters extends ReadonlyArray<ToolPresenter<ServerResult, ViewDefinitionContract>>, Operation extends ToolOperation>(tool: StructuredTool<Name, InputSchema, ServerResult, Error, Requirements, undefined, Presenters, Operation>) => StructuredTool<Name, InputSchema, ServerResult, Error, Requirements, ModelSchema, Presenters, Operation>;
+    readonly present: <ServerResult, View extends ViewDefinitionContract>(view: View, project: (result: ServerResult) => ViewInput<View> | undefined) => <Name extends string, InputSchema extends ToolSchema, Error, Requirements, ModelSchema extends ToolSchema | undefined, Presenters extends ReadonlyArray<ToolPresenter<ServerResult, ViewDefinitionContract>>, Operation extends ToolOperation>(tool: StructuredTool<Name, InputSchema, ServerResult, Error, Requirements, ModelSchema, Presenters, Operation>) => StructuredTool<Name, InputSchema, ServerResult, Error, Requirements, ModelSchema, readonly [...Presenters, ToolPresenter<ServerResult, View>], Operation>;
 };
 /** Parse failure retained only for documentation of owned schema boundaries. */
-export type ToolBoundaryParseError = ParseResult.ParseError;
+export type ToolBoundaryParseError = Schema.SchemaError;
 export {};

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 {};