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

package/LICENSE

@@ -19,4 +19,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-

package/README.md

@@ -14,7 +14,7 @@ The framework derives the model tool schemas, runtime validation, workflow
 state, browser protocol, and Effect requirements from those definitions.
 
 ```sh
-bun add @popcomputer/structured-chat effect
+bun add @popcomputer/structured-chat@next effect@^4.0.0-rc.109
 ```
 
 The published entry points are ESM-only and support Node.js 22 or newer.
@@ -28,40 +28,42 @@ import {
   Stage,
   Tool,
 } from "@popcomputer/structured-chat"
-import { Effect, Schema } from "effect"
+import { Schema } from "effect"
 
-const AgencyCards = defineView({
-  name: "agency_cards",
+const ResultCards = defineView({
+  name: "result_cards",
   version: 1,
   schema: Schema.Struct({
-    agencies: Schema.Array(
+    results: Schema.Array(
       Schema.Struct({
         id: Schema.String,
-        name: Schema.String,
-        reason: Schema.String,
+        title: Schema.String,
+        summary: Schema.String,
       }),
     ),
   }),
 })
 
-const SearchAgencies = defineTool({
-  name: "search_agencies",
-  description: "Find agencies relevant to the completed project brief.",
-  input: Schema.Struct({ query: Schema.NonEmptyTrimmedString }),
-  execute: ({ query }) => AgencySearch.find(query),
+const FindResources = defineTool({
+  name: "find_resources",
+  description: "Find resources relevant to the completed request.",
+  input: Schema.Struct({
+    query: Schema.Trimmed.check(Schema.isNonEmpty()),
+  }),
+  execute: ({ query }) => ResourceCatalog.search(query),
 }).pipe(
-  Tool.modelResult(AgencyEvidenceSchema, ({ evidence }) => evidence),
-  Tool.present(AgencyCards, ({ agencies }) => ({ agencies })),
+  Tool.modelResult(ResourceEvidenceSchema, ({ evidence }) => evidence),
+  Tool.present(ResultCards, ({ results }) => ({ results })),
 )
 
-const Matching = Stage.tools({
-  name: "matching",
-  instructions: ["Route the completed brief to one agency search."],
-  tools: [SearchAgencies],
+const Lookup = Stage.tools({
+  name: "lookup",
+  instructions: ["Route the completed request to one resource lookup."],
+  tools: [FindResources],
 })
 ```
 
-`SearchAgencies` is the single source of truth for one capability. Its input
+`FindResources` is the single source of truth for one capability. Its input
 schema becomes both the model-facing JSON Schema and the authoritative runtime
 parser. Its Effect error and service requirements remain typed.
 
@@ -76,6 +78,10 @@ The three result surfaces are deliberately separate:
 Internal data does not reach the model or browser merely because a tool loaded
 it.
 
+See the compile-checked
+[`resource-search.ts`](./examples/resource-search.ts) example for a complete
+tool, service, model projection, browser projection, and stage definition.
+
 ## Compose directly with document-graph
 
 Structured chat does not wrap or replace retrieval. An application-defined
@@ -83,24 +89,26 @@ Structured chat does not wrap or replace retrieval. An application-defined
 execution directly:
 
 ```ts
-import { FindAgencies } from "./agency-graph.js"
+import { SearchKnowledgeBase } from "./knowledge-graph.js"
 
-const SearchAgencies = defineTool({
-  name: "search_agencies",
-  description: "Find agencies supported by relevant work evidence.",
-  input: Schema.Struct({ query: Schema.NonEmptyTrimmedString }),
-  execute: ({ query }) => FindAgencies.search(query, { limit: 6 }),
+const FindResources = defineTool({
+  name: "find_resources",
+  description: "Find resources supported by relevant source evidence.",
+  input: Schema.Struct({
+    query: Schema.Trimmed.check(Schema.isNonEmpty()),
+  }),
+  execute: ({ query }) => SearchKnowledgeBase.search(query, { limit: 6 }),
 }).pipe(
-  Tool.modelResult(AgencyEvidenceSchema, toModelEvidence),
-  Tool.present(AgencyCards, toAgencyCards),
+  Tool.modelResult(ResourceEvidenceSchema, toModelEvidence),
+  Tool.present(ResultCards, toResultCards),
 )
 ```
 
-`FindAgencies` remains the application-owned graph retrieval policy: it can
-combine direct Agency profile matches with Work evidence reached through a
-typed relationship. Structured chat contributes the closed tool schema,
-stage policy, result projections, and UI protocol. The graph's typed failures
-and Effect requirements flow through the tool without another adapter layer.
+`SearchKnowledgeBase` remains the application-owned graph retrieval policy: it
+can combine direct resource matches with supporting documents reached through
+typed relationships. Structured chat contributes the closed tool schema, stage
+policy, result projections, and UI protocol. The graph's typed failures and
+Effect requirements flow through the tool without another adapter layer.
 
 ## Put a free-form conversation on rails
 
@@ -115,41 +123,40 @@ import {
 } from "@popcomputer/structured-chat"
 import { Schema } from "effect"
 
-const ProjectBrief = Stage.collect({
-  name: "project_brief",
+const RequestDetails = Stage.collect({
+  name: "request_details",
   questions: {
     guidance:
-      "Ask one conversational question at a time and briefly explain why the answer improves the match.",
+      "Ask one conversational question at a time and briefly explain why the answer improves the result.",
     escape: "Not sure yet",
   },
   fields: {
-    priority: Answer.semantic(Schema.NonEmptyTrimmedString, {
-      description:
-        "The unmet need the client most wants an agency to solve.",
+    goal: Answer.semantic(Schema.Trimmed.check(Schema.isNonEmpty()), {
+      description: "The outcome the user wants to achieve.",
       ask: Question.adaptiveChoice(
-        "Where would outside agency expertise help most?",
+        "What would you like help accomplishing?",
         {
           minimumOptions: 3,
           maximumOptions: 5,
           fallbackOptions: [
-            "Launch or grow a product",
-            "Build the brand long term",
-            "Fix a performance problem",
+            "Understand a topic",
+            "Compare available options",
+            "Plan the next steps",
           ],
         },
       ),
     }),
-    location: Answer.explicit(Schema.NonEmptyTrimmedString, {
-      description: "Where the client is based.",
-      ask: Question.fixed("Where are you based?"),
+    audience: Answer.explicit(Schema.Trimmed.check(Schema.isNonEmpty()), {
+      description: "Who the requested result is for.",
+      ask: Question.fixed("Who is this for?"),
     }),
   },
 })
 
-const Matchmaker = defineChat({
-  name: "agency_matchmaker",
+const ResourceFinder = defineChat({
+  name: "resource_finder",
   version: 1,
-  stages: [ProjectBrief, Matching],
+  stages: [RequestDetails, Lookup],
 })
 ```
 
@@ -170,7 +177,7 @@ while the field is pending. The value is validated against the answer schema
 at definition time and requires `questions.escape` to be configured; a
 confirmed field still requires its question to have been issued first.
 Fields without an escape value stay unresolved and are re-asked from another
-angle, so a client who genuinely cannot answer never blocks the workflow
+angle, so a user who genuinely cannot answer never blocks the workflow
 unless the application wants it to.
 
 For an adaptive choice, valid contextual model suggestions take precedence.
@@ -214,15 +221,15 @@ Applications can read the typed value and its provenance without reaching into
 the persisted state shape:
 
 ```ts
-const priority = Matchmaker.getAcceptedAnswer(
+const goal = ResourceFinder.getAcceptedAnswer(
   reply.turn.state,
-  ProjectBrief,
-  "priority",
+  RequestDetails,
+  "goal",
 )
 
-priority?.value
-priority?.evidence.messageIndex
-priority?.evidence.quote
+goal?.value
+goal?.evidence.messageIndex
+goal?.evidence.quote
 ```
 
 For semantic answers, the quote supports the model's inference; it does not
@@ -234,23 +241,23 @@ Keep parsing and business acceptance separate when a structurally valid value
 may still be unsuitable for the workflow:
 
 ```ts
-class BudgetTooLow extends Schema.TaggedError<BudgetTooLow>()(
-  "BudgetTooLow",
-  { minimum: Schema.Number },
+class ResultLimitOutOfRange extends Schema.TaggedError<ResultLimitOutOfRange>()(
+  "ResultLimitOutOfRange",
+  { minimum: Schema.Number, maximum: Schema.Number },
 ) {}
 
-const Budget = Answer.explicit(Schema.Number, {
+const ResultLimit = Answer.explicit(Schema.Number, {
   // The description remains model-visible, so repeat acceptance constraints.
-  description: "Project budget in GBP; must be at least 5,000",
-  ask: Question.fixed("What budget have you set aside?"),
-  validate: (budget) =>
-    budget >= 5_000
+  description: "Number of results; must be a whole number from 1 to 20",
+  ask: Question.fixed("How many results would you like?"),
+  validate: (limit) =>
+    Number.isInteger(limit) && limit >= 1 && limit <= 20
       ? Effect.void
-      : Effect.fail(new BudgetTooLow({ minimum: 5_000 })),
+      : Effect.fail(
+          new ResultLimitOutOfRange({ minimum: 1, maximum: 20 }),
+        ),
   reject: {
-    ask: Question.fixed(
-      "Our minimum engagement is £5,000. Could you revise the budget?",
-    ),
+    ask: Question.fixed("Choose a whole number from 1 to 20."),
   },
 })
 ```
@@ -313,8 +320,8 @@ const program = Effect.gen(function* () {
   const request = yield* parseRequest(StructuredChatTurnRequestSchema)
   const publicSessionId = request.session?.id ?? crypto.randomUUID()
 
-  const reply = yield* Matchmaker.reply({
-    namespace: authenticatedUser.id,
+  const reply = yield* ResourceFinder.reply({
+    namespace: authenticatedActor.id,
     sessionId: publicSessionId,
     expectedRevision: request.session?.revision,
     message: request.message,
@@ -324,7 +331,7 @@ const program = Effect.gen(function* () {
     { ...reply, sessionId: publicSessionId },
     {
       result: ({ result }) => [
-        Text.make("These are the strongest evidence-backed matches."),
+        Text.make("Here are the most relevant evidence-backed resources."),
         ...result.views,
       ],
     },
@@ -357,13 +364,13 @@ meaning.
 ## Continue naturally after the first tool result
 
 `Stage.tools(...)` stays active by default. A user can refine the previous
-search without restarting the collection stage:
+lookup without restarting the collection stage:
 
 ```txt
-User: We need a public-sector service redesign.
-Assistant: [search results]
-User: Favour agencies with accessibility experience.
-Assistant: [refined search results]
+User: We need onboarding guidance for a new team.
+Assistant: [resource results]
+User: Prefer concise resources with practical examples.
+Assistant: [refined resource results]
 ```
 
 When a tool defines `Tool.modelResult(...)`, each bounded result is retained in
@@ -389,20 +396,20 @@ Declare side effects honestly. A command receives the package-derived stable
 ID that its application endpoint must use as an idempotency key:
 
 ```ts
-const Submit = defineCommand({
-  name: "submit_application",
-  description: "Submit the confirmed application once.",
-  input: SubmitApplicationInput,
+const CreateRequest = defineCommand({
+  name: "create_request",
+  description: "Create the confirmed request once.",
+  input: CreateRequestInput,
   execute: (input, { commandId }) =>
-    Applications.submit(input, { idempotencyKey: commandId }),
+    Requests.create(input, { idempotencyKey: commandId }),
 }).pipe(
-  Tool.present(SubmissionReceipt, toSubmissionReceipt),
+  Tool.present(RequestReceipt, toRequestReceipt),
 )
 
-const SubmitApplication = Stage.command({
-  name: "submit_application",
-  instructions: ["Submit the confirmed application."],
-  command: Submit,
+const CreateRequestStage = Stage.command({
+  name: "create_request",
+  instructions: ["Create the confirmed request."],
+  command: CreateRequest,
 })
 ```
 
@@ -431,10 +438,10 @@ Repair is disabled by default. Enable it only on chats whose final stage is a
 repeatable query:
 
 ```ts
-const Matchmaker = defineChat({
-  name: "agency_matchmaker",
+const RepairableResourceFinder = defineChat({
+  name: "resource_finder",
   version: 2,
-  stages: [ProjectBrief, Matching],
+  stages: [RequestDetails, Lookup],
   repair: Repair.standard({ maximumCorrections: 5 }),
 })
 ```
@@ -550,21 +557,21 @@ import {
 } from "@popcomputer/structured-chat/assistant-ui"
 import type { ReactNode } from "react"
 
-const AgencyCardsUI = makeAssistantView(AgencyCards, {
-  render: AgencyCardsComponent,
+const ResultCardsUI = makeAssistantView(ResultCards, {
+  render: ResultCardsComponent,
   fallback: InvalidCardFallback,
 })
 
 const QuestionUI = makeAssistantView(CollectQuestionView, {
-  render: ProjectQuestion,
+  render: RequestQuestion,
   fallback: InvalidQuestionFallback,
 })
 
 const model = makeAssistantChatModelAdapter({
-  endpoint: "/api/matchmaker/turn",
+  endpoint: "/api/resource-finder/turn",
 })
 
-export function MatchmakerRuntime({
+export function ResourceFinderRuntime({
   children,
 }: Readonly<{ children: ReactNode }>) {
   const runtime = useLocalRuntime(model)
@@ -572,7 +579,7 @@ export function MatchmakerRuntime({
   return (
     <AssistantRuntimeProvider runtime={runtime}>
       <QuestionUI />
-      <AgencyCardsUI />
+      <ResultCardsUI />
       {children}
     </AssistantRuntimeProvider>
   )
@@ -598,16 +605,16 @@ history as authoritative.
 The default remains one call:
 
 ```ts
-const result = yield* Matching.run(messages)
+const result = yield* Lookup.run(messages)
 ```
 
 Approval flows, dry runs, and evals can stop after a strictly parsed proposal:
 
 ```ts
-const call = yield* Matching.plan(messages)
+const call = yield* Lookup.plan(messages)
 
 // Application-owned review or approval.
-const result = yield* Matching.toolSet.execute(call)
+const result = yield* Lookup.toolSet.execute(call)
 ```
 
 `plan` uses the same trusted instructions, closed tool set, guards, provider
@@ -627,15 +634,22 @@ import {
 } from "@popcomputer/structured-chat/testing"
 
 const ModelTest = Scenario.model(
-  Scenario.answers(ProjectBrief, {
-    location: Scenario.quoted("Leeds", { quote: "based in Leeds" }),
+  Scenario.answers(RequestDetails, {
+    goal: Scenario.quoted("prepare an onboarding plan", {
+      quote: "prepare an onboarding plan",
+    }),
+    audience: Scenario.quoted("new team members", {
+      quote: "new team members",
+    }),
+  }),
+  Scenario.call(FindResources, {
+    query: "onboarding plan for new team members",
   }),
-  Scenario.call(SearchAgencies, { query: "Leeds public services" }),
 )
 
-const reply = yield* Matchmaker.reply({
+const reply = yield* ResourceFinder.reply({
   sessionId: "scenario-1",
-  message: "We are based in Leeds.",
+  message: "Help me prepare an onboarding plan for new team members.",
 }).pipe(
   Effect.provide(Layer.merge(ModelTest, inMemoryChatSessionStore)),
 )
@@ -657,8 +671,8 @@ rules:
 
 ```ts
 Scenario.repairs(
-  Scenario.replace(ProjectBrief, "location", "Manchester", {
-    quote: "Actually, Manchester",
+  Scenario.replace(RequestDetails, "audience", "engineering managers", {
+    quote: "Actually, engineering managers",
   }),
 )
 ```
@@ -703,10 +717,10 @@ const InjectionPolicy = defineModelGuard({
     PolicyService.checkCall({ messages, call }),
 })
 
-const Matching = Stage.tools({
-  name: "matching",
-  instructions: ["Route the completed brief to one search."],
-  tools: [SearchAgencies],
+const Lookup = Stage.tools({
+  name: "lookup",
+  instructions: ["Route the completed request to one resource lookup."],
+  tools: [FindResources],
   guards: [InjectionPolicy],
 })
 ```

package/dist/adapters/openai-compatible-model.d.ts

@@ -3,7 +3,7 @@ import { StructuredChatModel, type ChatModelUnavailableReasonSchema, type Struct
 import type { ModelToolDefinition } from "../core/tool.js";
 import { type JsonValue } from "../core/json-value.js";
 /** Bounded timeout for one provider tool-call request. */
-export declare const StructuredChatRequestTimeoutSchema: Schema.filter<Schema.filter<typeof Schema.Number>>;
+export declare const StructuredChatRequestTimeoutSchema: Schema.Number;
 interface OpenAICompatibleMessage {
     readonly role: "system" | "user";
     readonly content: string;
@@ -21,10 +21,10 @@ type OpenAICompatibleInputValue = JsonValue | ReadonlyArray<OpenAICompatibleMess
 interface OpenAICompatibleInput {
     readonly [key: string]: OpenAICompatibleInputValue;
 }
-declare const OpenAICompatibleToolArgumentsSchema: Schema.Literal<["guided", "strict"]>;
+declare const OpenAICompatibleToolArgumentsSchema: Schema.Literals<readonly ["guided", "strict"]>;
 type OpenAICompatibleToolArguments = Schema.Schema.Type<typeof OpenAICompatibleToolArgumentsSchema>;
 /** Bounded provider model identifier used for routing and diagnostics. */
-export declare const StructuredChatModelIdSchema: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
+export declare const StructuredChatModelIdSchema: Schema.Trimmed;
 /** Bounded provider model identifier used for routing and diagnostics. */
 export type StructuredChatModelId = Schema.Schema.Type<typeof StructuredChatModelIdSchema>;
 /** One provider request with its parsed model identifier. */
@@ -44,7 +44,7 @@ export interface CloudflareWorkersAIProviderConfig extends OpenAICompatibleProvi
 export interface OpenAIProviderConfig extends OpenAICompatibleProviderConfig {
 }
 /** Stable identifier for a built-in model provider. */
-export declare const StructuredChatProviderIdSchema: Schema.Literal<["cloudflare-workers-ai", "openai"]>;
+export declare const StructuredChatProviderIdSchema: Schema.Literals<readonly ["cloudflare-workers-ai", "openai"]>;
 /** Stable identifier for a built-in model provider. */
 export type StructuredChatProviderId = Schema.Schema.Type<typeof StructuredChatProviderIdSchema>;
 interface StructuredChatProviderRuntime {

package/dist/adapters/openai-compatible-model.js

@@ -1,13 +1,19 @@
-import { Effect, Either, Layer, Schema } from "effect";
+import { Effect, Exit, Layer, Schema } from "effect";
 import { ChatModelUnavailable, StructuredChatModel, UnsupportedModelToolSchema, } from "../core/model.js";
 import { JsonValueSchema, } from "../core/json-value.js";
 /** Bounded timeout for one provider tool-call request. */
-export const StructuredChatRequestTimeoutSchema = Schema.Number.pipe(Schema.int(), Schema.between(1, 60_000));
-const OpenAICompatibleToolArgumentsSchema = Schema.Literal("guided", "strict");
+export const StructuredChatRequestTimeoutSchema = Schema.Number.check(Schema.isInt(), Schema.isBetween({ minimum: 1, maximum: 60_000 }));
+const OpenAICompatibleToolArgumentsSchema = Schema.Literals([
+    "guided",
+    "strict",
+]);
 /** Bounded provider model identifier used for routing and diagnostics. */
-export const StructuredChatModelIdSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(200));
+export const StructuredChatModelIdSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(200));
 /** Stable identifier for a built-in model provider. */
-export const StructuredChatProviderIdSchema = Schema.Literal("cloudflare-workers-ai", "openai");
+export const StructuredChatProviderIdSchema = Schema.Literals([
+    "cloudflare-workers-ai",
+    "openai",
+]);
 const StructuredChatProviderRuntime = Symbol("@popcomputer/structured-chat/StructuredChatProviderRuntime");
 const openAIModelSupportsStrictToolArguments = (model) => /^(?:chat-latest$|gpt-4o(?:-|$)|gpt-4\.1(?:-|$)|gpt-5(?:[.-]|$)|o3(?:-|$)|o4(?:-|$))/u.test(model);
 const makeProvider = (id, config, toolArguments) => {
@@ -45,28 +51,24 @@ export const ModelProvider = {
     },
 };
 const ToolCallResponseSchema = Schema.Struct({
-    choices: Schema.Tuple(Schema.Struct({
-        message: Schema.Struct({
-            tool_calls: Schema.Tuple(Schema.Struct({
-                function: Schema.Struct({
-                    name: Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(100)),
-                    arguments: Schema.String.pipe(Schema.maxLength(20_000)),
-                }),
-            })),
+    choices: Schema.Tuple([
+        Schema.Struct({
+            message: Schema.Struct({
+                tool_calls: Schema.Tuple([
+                    Schema.Struct({
+                        function: Schema.Struct({
+                            name: Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(100)),
+                            arguments: Schema.String.check(Schema.isMaxLength(20_000)),
+                        }),
+                    }),
+                ]),
+            }),
         }),
-    })),
+    ]),
 });
 const unavailable = (reason) => new ChatModelUnavailable({ reason });
-const parseJson = (input) => Effect.try({
-    // SAFETY: JSON.parse without a reviver can only return a JSON value when
-    // parsing succeeds; failures are mapped to the typed unavailable reason.
-    try: () => JSON.parse(input),
-    catch: () => unavailable("invalid_response"),
-});
-const JsonSchemaObjectSchema = Schema.Record({
-    key: Schema.String,
-    value: JsonValueSchema,
-});
+const parseJson = (input) => Schema.decodeEffect(Schema.fromJsonString(JsonValueSchema))(input).pipe(Effect.mapError(() => unavailable("invalid_response")));
+const JsonSchemaObjectSchema = Schema.Record(Schema.String, JsonValueSchema);
 const isJsonSchemaObject = (value) => Schema.is(JsonSchemaObjectSchema)(value);
 const appendJsonPointer = (path, segment) => `${path}/${segment.replaceAll("~", "~0").replaceAll("/", "~1")}`;
 const findStrictObjectIssue = (schema, path) => {
@@ -145,15 +147,15 @@ const findStrictSchemaIssue = (schema) => {
     return findStrictObjectIssue(schema, "#");
 };
 const strictToolIssue = (tool) => {
-    const parsedSchema = Schema.decodeUnknownEither(JsonSchemaObjectSchema)(tool.inputSchema, { onExcessProperty: "error" });
-    if (Either.isLeft(parsedSchema)) {
+    const parsedSchema = Schema.decodeUnknownExit(JsonSchemaObjectSchema)(tool.inputSchema, { onExcessProperty: "error" });
+    if (Exit.isFailure(parsedSchema)) {
         return new UnsupportedModelToolSchema({
             tool: tool.name,
             path: "#",
             reason: "root_not_object",
         });
     }
-    const issue = findStrictSchemaIssue(parsedSchema.right);
+    const issue = findStrictSchemaIssue(parsedSchema.value);
     return issue === undefined
         ? undefined
         : new UnsupportedModelToolSchema({
@@ -215,10 +217,10 @@ export const makeStructuredChatModel = (config) => {
         requestTool: (request) => toProviderInput(request, runtime.requestOptions, runtime.toolArguments).pipe(Effect.flatMap((input) => Effect.tryPromise({
             try: (signal) => runtime.complete(input, signal),
             catch: (cause) => unavailable(classifyError(cause)),
-        })), Effect.timeoutFail({
+        })), Effect.timeoutOrElse({
             duration: timeoutMilliseconds,
-            onTimeout: () => unavailable("timed_out"),
-        }), Effect.flatMap((response) => Schema.decodeUnknown(ToolCallResponseSchema)(response).pipe(Effect.mapError(() => unavailable("invalid_response")))), Effect.flatMap((response) => {
+            orElse: () => Effect.fail(unavailable("timed_out")),
+        }), Effect.flatMap((response) => Schema.decodeUnknownEffect(ToolCallResponseSchema)(response).pipe(Effect.mapError(() => unavailable("invalid_response")))), Effect.flatMap((response) => {
             const tool = response.choices[0].message.tool_calls[0].function;
             return parseJson(tool.arguments).pipe(Effect.map((arguments_) => ({
                 name: tool.name,
@@ -228,4 +230,4 @@ export const makeStructuredChatModel = (config) => {
     };
 };
 /** Build an Effect layer for one provider-backed structured chat model. */
-export const structuredChatModelLayer = (config) => Layer.succeed(StructuredChatModel, makeStructuredChatModel(config));
+export const structuredChatModelLayer = (config) => Layer.succeed(StructuredChatModel, StructuredChatModel.of(makeStructuredChatModel(config)));

package/dist/core/answer.d.ts

@@ -1,14 +1,14 @@
 import { Effect, Schema } from "effect";
 import type { ChoiceQuestion, FixedQuestion, QuestionDefinition, QuestionDefinitionContract } from "./question.js";
 /** How strongly a collect-stage answer must be grounded in user messages. */
-export declare const AnswerModeSchema: Schema.Literal<["semantic", "explicit", "confirmed"]>;
+export declare const AnswerModeSchema: Schema.Literals<readonly ["semantic", "explicit", "confirmed"]>;
 /** How strongly a collect-stage answer must be grounded in user messages. */
 export type AnswerMode = Schema.Schema.Type<typeof AnswerModeSchema>;
 /** Minimum runtime shape retained for every collect-stage answer. */
 export interface AnswerDefinitionContract {
     readonly _tag: "AnswerDefinition";
     readonly mode: AnswerMode;
-    readonly schema: Schema.Schema.AnyNoContext;
+    readonly schema: Schema.ConstraintCodec<unknown, unknown>;
     readonly description: string;
     readonly question: QuestionDefinitionContract;
     readonly validate?: (value: never) => Effect.Effect<void, unknown, unknown>;
@@ -20,16 +20,16 @@ export interface AnswerDefinitionContract {
     };
 }
 /** One typed fact required by a collect stage. */
-export interface AnswerDefinition<Mode extends AnswerMode, ValueSchema extends Schema.Schema.AnyNoContext, Error = never, Requirements = never> extends AnswerDefinitionContract {
+export interface AnswerDefinition<Mode extends AnswerMode, ValueSchema extends Schema.ConstraintCodec<unknown, unknown>, Error = never, Requirements = never> extends AnswerDefinitionContract {
     readonly mode: Mode;
     readonly schema: ValueSchema;
-    readonly question: QuestionDefinition<Schema.Schema.Type<ValueSchema>>;
-    readonly validate?: (value: Schema.Schema.Type<ValueSchema>) => Effect.Effect<void, Error, Requirements>;
+    readonly question: QuestionDefinition<ValueSchema["Type"]>;
+    readonly validate?: (value: ValueSchema["Type"]) => Effect.Effect<void, Error, Requirements>;
     readonly reject?: {
-        readonly ask: FixedQuestion | ChoiceQuestion<Schema.Schema.Type<ValueSchema>>;
+        readonly ask: FixedQuestion | ChoiceQuestion<ValueSchema["Type"]>;
     };
     readonly escape?: {
-        readonly value: Schema.Schema.Type<ValueSchema>;
+        readonly value: ValueSchema["Type"];
     };
 }
 interface DefineAnswerBase<Value> {
@@ -58,12 +58,12 @@ export interface DefineValidatedAnswerInput<Value, Error, Requirements> extends
 }
 /** Configuration shared by all answer grounding modes. */
 export type DefineAnswerInput<Value, Error = never, Requirements = never> = DefineUnvalidatedAnswerInput<Value> | DefineValidatedAnswerInput<Value, Error, Requirements>;
-declare function semantic<ValueSchema extends Schema.Schema.AnyNoContext>(schema: ValueSchema, input: DefineUnvalidatedAnswerInput<Schema.Schema.Type<ValueSchema>>): AnswerDefinition<"semantic", ValueSchema, never, never>;
-declare function semantic<ValueSchema extends Schema.Schema.AnyNoContext, Error, Requirements>(schema: ValueSchema, input: DefineValidatedAnswerInput<Schema.Schema.Type<ValueSchema>, Error, Requirements>): AnswerDefinition<"semantic", ValueSchema, Error, Requirements>;
-declare function explicit<ValueSchema extends Schema.Schema.AnyNoContext>(schema: ValueSchema, input: DefineUnvalidatedAnswerInput<Schema.Schema.Type<ValueSchema>>): AnswerDefinition<"explicit", ValueSchema, never, never>;
-declare function explicit<ValueSchema extends Schema.Schema.AnyNoContext, Error, Requirements>(schema: ValueSchema, input: DefineValidatedAnswerInput<Schema.Schema.Type<ValueSchema>, Error, Requirements>): AnswerDefinition<"explicit", ValueSchema, Error, Requirements>;
-declare function confirmed<ValueSchema extends Schema.Schema.AnyNoContext>(schema: ValueSchema, input: DefineUnvalidatedAnswerInput<Schema.Schema.Type<ValueSchema>>): AnswerDefinition<"confirmed", ValueSchema, never, never>;
-declare function confirmed<ValueSchema extends Schema.Schema.AnyNoContext, Error, Requirements>(schema: ValueSchema, input: DefineValidatedAnswerInput<Schema.Schema.Type<ValueSchema>, Error, Requirements>): AnswerDefinition<"confirmed", ValueSchema, Error, Requirements>;
+declare function semantic<ValueSchema extends Schema.ConstraintCodec<unknown, unknown>>(schema: ValueSchema, input: DefineUnvalidatedAnswerInput<ValueSchema["Type"]>): AnswerDefinition<"semantic", ValueSchema, never, never>;
+declare function semantic<ValueSchema extends Schema.ConstraintCodec<unknown, unknown>, Error, Requirements>(schema: ValueSchema, input: DefineValidatedAnswerInput<ValueSchema["Type"], Error, Requirements>): AnswerDefinition<"semantic", ValueSchema, Error, Requirements>;
+declare function explicit<ValueSchema extends Schema.ConstraintCodec<unknown, unknown>>(schema: ValueSchema, input: DefineUnvalidatedAnswerInput<ValueSchema["Type"]>): AnswerDefinition<"explicit", ValueSchema, never, never>;
+declare function explicit<ValueSchema extends Schema.ConstraintCodec<unknown, unknown>, Error, Requirements>(schema: ValueSchema, input: DefineValidatedAnswerInput<ValueSchema["Type"], Error, Requirements>): AnswerDefinition<"explicit", ValueSchema, Error, Requirements>;
+declare function confirmed<ValueSchema extends Schema.ConstraintCodec<unknown, unknown>>(schema: ValueSchema, input: DefineUnvalidatedAnswerInput<ValueSchema["Type"]>): AnswerDefinition<"confirmed", ValueSchema, never, never>;
+declare function confirmed<ValueSchema extends Schema.ConstraintCodec<unknown, unknown>, Error, Requirements>(schema: ValueSchema, input: DefineValidatedAnswerInput<ValueSchema["Type"], Error, Requirements>): AnswerDefinition<"confirmed", ValueSchema, Error, Requirements>;
 /** Constructors for semantic, explicit, and explicitly confirmed facts. */
 export declare const Answer: {
     readonly semantic: typeof semantic;