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

package/dist/core/session.d.ts

@@ -1,53 +1,47 @@
 import { Context, Effect, Schema } from "effect";
 import { type UntrustedMessage } from "./model.js";
 /** Stable application-owned identifier for one chat session. */
-export declare const ChatSessionIdSchema: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
+export declare const ChatSessionIdSchema: Schema.Trimmed;
 /** Optional application-owned partition for otherwise public session IDs. */
-export declare const ChatSessionNamespaceSchema: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
+export declare const ChatSessionNamespaceSchema: Schema.Trimmed;
 /** Opaque optimistic revision emitted by a session store adapter. */
-export declare const ChatSessionRevisionSchema: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
+export declare const ChatSessionRevisionSchema: Schema.Trimmed;
 /** Persisted session snapshot revalidated by the chat runtime after loading. */
 export declare const ChatSessionSnapshotSchema: Schema.Struct<{
-    revision: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
-    state: typeof Schema.Unknown;
-    messages: Schema.filter<Schema.Array$<Schema.Struct<{
-        role: Schema.Literal<["user", "assistant"]>;
-        content: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
-    }>>>;
+    readonly revision: Schema.Trimmed;
+    readonly state: Schema.Unknown;
+    readonly messages: Schema.$Array<Schema.Struct<{
+        readonly role: Schema.Literals<readonly ["user", "assistant"]>;
+        readonly content: Schema.Trimmed;
+    }>>;
 }>;
 /** Parsed persisted chat session snapshot. */
 export type ChatSessionSnapshot = Schema.Schema.Type<typeof ChatSessionSnapshotSchema>;
 /** Successful optimistic session replacement returned by an adapter. */
 export declare const ChatSessionReplacementSchema: Schema.Struct<{
-    revision: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
+    readonly revision: Schema.Trimmed;
 }>;
 /** Successful optimistic session replacement returned by an adapter. */
 export type ChatSessionReplacement = Schema.Schema.Type<typeof ChatSessionReplacementSchema>;
 /** Safe reason that a session store dependency was unavailable. */
-export declare const ChatSessionStoreUnavailableReasonSchema: Schema.Literal<["load_failed", "write_failed"]>;
-declare const ChatSessionStoreUnavailable_base: Schema.TaggedErrorClass<ChatSessionStoreUnavailable, "ChatSessionStoreUnavailable", {
-    readonly _tag: Schema.tag<"ChatSessionStoreUnavailable">;
-} & {
-    reason: Schema.Literal<["load_failed", "write_failed"]>;
-}>;
+export declare const ChatSessionStoreUnavailableReasonSchema: Schema.Literals<readonly ["load_failed", "write_failed"]>;
+declare const ChatSessionStoreUnavailable_base: Schema.Class<ChatSessionStoreUnavailable, Schema.TaggedStruct<"ChatSessionStoreUnavailable", {
+    readonly reason: Schema.Literals<readonly ["load_failed", "write_failed"]>;
+}>, import("effect/Cause").YieldableError>;
 /** A session store adapter could not load or replace state. */
 export declare class ChatSessionStoreUnavailable extends ChatSessionStoreUnavailable_base {
 }
-declare const ChatSessionConflict_base: Schema.TaggedErrorClass<ChatSessionConflict, "ChatSessionConflict", {
-    readonly _tag: Schema.tag<"ChatSessionConflict">;
-} & {
-    reason: Schema.Literal<["concurrent_update"]>;
-}>;
+declare const ChatSessionConflict_base: Schema.Class<ChatSessionConflict, Schema.TaggedStruct<"ChatSessionConflict", {
+    readonly reason: Schema.Literal<"concurrent_update">;
+}>, import("effect/Cause").YieldableError>;
 /** A concurrent or stale transition attempted to replace newer state. */
 export declare class ChatSessionConflict extends ChatSessionConflict_base {
 }
 /** Safe reason that session input or persisted data was rejected. */
-export declare const InvalidChatSessionReasonSchema: Schema.Literal<["invalid_input", "invalid_snapshot", "invalid_state", "invalid_replacement", "history_limit"]>;
-declare const InvalidChatSession_base: Schema.TaggedErrorClass<InvalidChatSession, "InvalidChatSession", {
-    readonly _tag: Schema.tag<"InvalidChatSession">;
-} & {
-    reason: Schema.Literal<["invalid_input", "invalid_snapshot", "invalid_state", "invalid_replacement", "history_limit"]>;
-}>;
+export declare const InvalidChatSessionReasonSchema: Schema.Literals<readonly ["invalid_input", "invalid_snapshot", "invalid_state", "invalid_replacement", "history_limit"]>;
+declare const InvalidChatSession_base: Schema.Class<InvalidChatSession, Schema.TaggedStruct<"InvalidChatSession", {
+    readonly reason: Schema.Literals<readonly ["invalid_input", "invalid_snapshot", "invalid_state", "invalid_replacement", "history_limit"]>;
+}>, import("effect/Cause").YieldableError>;
 /** Session input or persisted state failed runtime validation. */
 export declare class InvalidChatSession extends InvalidChatSession_base {
 }
@@ -71,7 +65,7 @@ export interface ChatSessionStoreService {
     /** Atomically replace one complete session at its expected revision. */
     readonly replace: (input: ReplaceChatSessionInput) => Effect.Effect<unknown, ChatSessionStoreUnavailable | ChatSessionConflict>;
 }
-declare const ChatSessionStore_base: Context.TagClass<ChatSessionStore, "@popcomputer/structured-chat/ChatSessionStore", ChatSessionStoreService>;
+declare const ChatSessionStore_base: Context.ServiceClass<ChatSessionStore, "@popcomputer/structured-chat/ChatSessionStore", ChatSessionStoreService>;
 /** Effect service for the configured server-owned chat session store. */
 export declare class ChatSessionStore extends ChatSessionStore_base {
 }

package/dist/core/session.js

@@ -1,23 +1,26 @@
 import { Context, Effect, Schema } from "effect";
 import { UntrustedMessageSchema } from "./model.js";
 /** Stable application-owned identifier for one chat session. */
-export const ChatSessionIdSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(200), Schema.pattern(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/));
+export const ChatSessionIdSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(200), Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/));
 /** Optional application-owned partition for otherwise public session IDs. */
-export const ChatSessionNamespaceSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(200), Schema.pattern(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/));
+export const ChatSessionNamespaceSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(200), Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/));
 /** Opaque optimistic revision emitted by a session store adapter. */
-export const ChatSessionRevisionSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(200), Schema.pattern(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/));
+export const ChatSessionRevisionSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(200), Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/));
 /** Persisted session snapshot revalidated by the chat runtime after loading. */
 export const ChatSessionSnapshotSchema = Schema.Struct({
     revision: ChatSessionRevisionSchema,
     state: Schema.Unknown,
-    messages: Schema.Array(UntrustedMessageSchema).pipe(Schema.maxItems(200)),
+    messages: Schema.Array(UntrustedMessageSchema).check(Schema.isMaxLength(200)),
 });
 /** Successful optimistic session replacement returned by an adapter. */
 export const ChatSessionReplacementSchema = Schema.Struct({
     revision: ChatSessionRevisionSchema,
 });
 /** Safe reason that a session store dependency was unavailable. */
-export const ChatSessionStoreUnavailableReasonSchema = Schema.Literal("load_failed", "write_failed");
+export const ChatSessionStoreUnavailableReasonSchema = Schema.Literals([
+    "load_failed",
+    "write_failed",
+]);
 /** A session store adapter could not load or replace state. */
 export class ChatSessionStoreUnavailable extends Schema.TaggedError()("ChatSessionStoreUnavailable", { reason: ChatSessionStoreUnavailableReasonSchema }) {
 }
@@ -25,10 +28,16 @@ export class ChatSessionStoreUnavailable extends Schema.TaggedError()("ChatSessi
 export class ChatSessionConflict extends Schema.TaggedError()("ChatSessionConflict", { reason: Schema.Literal("concurrent_update") }) {
 }
 /** Safe reason that session input or persisted data was rejected. */
-export const InvalidChatSessionReasonSchema = Schema.Literal("invalid_input", "invalid_snapshot", "invalid_state", "invalid_replacement", "history_limit");
+export const InvalidChatSessionReasonSchema = Schema.Literals([
+    "invalid_input",
+    "invalid_snapshot",
+    "invalid_state",
+    "invalid_replacement",
+    "history_limit",
+]);
 /** Session input or persisted state failed runtime validation. */
 export class InvalidChatSession extends Schema.TaggedError()("InvalidChatSession", { reason: InvalidChatSessionReasonSchema }) {
 }
 /** Effect service for the configured server-owned chat session store. */
-export class ChatSessionStore extends Context.Tag("@popcomputer/structured-chat/ChatSessionStore")() {
+export class ChatSessionStore extends Context.Service()("@popcomputer/structured-chat/ChatSessionStore") {
 }

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

@@ -1,3 +1,3 @@
 import { Schema } from "effect";
 /** Stable machine-facing name for one structured chat stage. */
-export declare const StageNameSchema: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
+export declare const StageNameSchema: Schema.Trimmed;

package/dist/core/stage-name.js

@@ -1,3 +1,3 @@
 import { Schema } from "effect";
 /** Stable machine-facing name for one structured chat stage. */
-export const StageNameSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(100), Schema.pattern(/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/));
+export const StageNameSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(100), Schema.isPattern(/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/));

package/dist/core/stage.d.ts

@@ -2,11 +2,11 @@ import { Effect, Schema } from "effect";
 import { StructuredChatModel, type ChatModelUnavailable, type UnsupportedModelToolSchema, type UntrustedMessage } from "./model.js";
 import type { ModelGuardError, ModelGuardRequirements, ModelGuardTuple } from "./model-guard.js";
 import { type ToolSet, type ToolSetCall, type ToolSetError, type ToolSetExecution, type ToolSetRequirements, type ToolTuple } from "./tool-set.js";
-import type { CommandDefinitionContract, CommandExecutionContext, InvalidToolCall, InvalidToolProjection, StructuredCommand, ToolCall, ToolExecution, QueryToolDefinitionContract } from "./tool.js";
+import type { CommandDefinitionContract, CommandExecutionContext, InvalidToolCall, InvalidToolProjection, StructuredCommand, ToolCall, ToolExecution, QueryToolDefinitionContract, ToolSchema } from "./tool.js";
 import { type StructuredDefinition } from "./definition.js";
 export { StageNameSchema } from "./stage-name.js";
 /** State transition applied after one tool-stage execution. */
-export declare const ToolStageAfterExecutionSchema: Schema.Literal<["stay", "complete"]>;
+export declare const ToolStageAfterExecutionSchema: Schema.Literals<readonly ["stay", "complete"]>;
 /** State transition applied after one tool-stage execution. */
 export type ToolStageAfterExecution = Schema.Schema.Type<typeof ToolStageAfterExecutionSchema>;
 /** Definition input for one stage-scoped, repeatable tool step. */
@@ -21,8 +21,8 @@ export interface DefineToolStageInput<Name extends string, Tools extends ToolTup
 export interface ToolStageRuntime {
     readonly afterExecution: ToolStageAfterExecution;
     readonly toolNames: ReadonlyArray<string>;
-    readonly planWith: (messages: ReadonlyArray<UntrustedMessage>, additionalTool: QueryToolDefinitionContract) => Effect.Effect<ToolCall<string, Schema.Schema.AnyNoContext>, unknown, unknown>;
-    readonly execute: (call: ToolCall<string, Schema.Schema.AnyNoContext>) => Effect.Effect<unknown, unknown, unknown>;
+    readonly planWith: (messages: ReadonlyArray<UntrustedMessage>, additionalTool: QueryToolDefinitionContract) => Effect.Effect<ToolCall<string, ToolSchema>, unknown, unknown>;
+    readonly execute: (call: ToolCall<string, ToolSchema>) => Effect.Effect<unknown, unknown, unknown>;
     readonly run: (messages: ReadonlyArray<UntrustedMessage>) => Effect.Effect<unknown, unknown, unknown>;
 }
 declare const toolStageRuntime: unique symbol;

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