@popcomputer/structured-chat 0.1.0 → 0.2.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>
   )
@@ -593,21 +600,74 @@ that expose message editing, regeneration, or persistent branching should pair
 it with an application-owned branch/session policy rather than treating browser
 history as authoritative.
 
+## Inspect development state
+
+The optional debug inspector shows the current stage, stage progress, required
+fields, accepted values, issued questions, and supporting evidence. It uses a
+small package-owned panel inspired by DialKit, without adding DialKit or another
+runtime dependency.
+
+Debug data uses a separate, explicit response contract. Select it on an
+authenticated development endpoint:
+
+```ts
+import {
+  presentChatDebugReply,
+  presentChatReply,
+} from "@popcomputer/structured-chat"
+
+const response = debugAccessGranted
+  ? yield* presentChatDebugReply(
+      ResourceFinder,
+      { ...reply, sessionId: publicSessionId },
+      { inspection: { evidence: "include" } },
+    )
+  : yield* presentChatReply({ ...reply, sessionId: publicSessionId })
+```
+
+Connect that endpoint to the inspector store:
+
+```tsx
+import { makeAssistantChatModelAdapter } from "@popcomputer/structured-chat/assistant-ui"
+import {
+  createStructuredChatDebugStore,
+  StructuredChatDebugPanel,
+} from "@popcomputer/structured-chat/assistant-ui/debug"
+
+const debugStore = createStructuredChatDebugStore()
+const model = makeAssistantChatModelAdapter({
+  endpoint: "/api/resource-finder/debug/turn",
+  onDebugSnapshot: debugStore.receive,
+})
+
+export function ResourceFinderDebugPanel() {
+  return <StructuredChatDebugPanel store={debugStore} />
+}
+```
+
+Without `onDebugSnapshot`, the normal adapter continues to reject a response
+containing debug data. Hiding or unmounting the panel is not an authorization
+boundary: the server must decide whether to emit the debug response. Use
+`evidence: "omit"` when transcript quotes should not cross that boundary.
+Create one store per chat runtime; it reflects the most recently completed
+debug response. Observer failures are isolated and never change the outcome of
+the persisted chat turn.
+
 ## Plan without executing
 
 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 +687,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 +724,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 +770,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)));