@caldrix-ai/aerix 0.0.0-stage → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+Format after [Keep a Changelog](https://keepachangelog.com/); versions are independent semver, tagged
+`aerix-js-v<version>`.
+
+## 0.1.1 — 2026-11-03
+
+### Changed
+
+- The `@caldrix-ai/caldrix` peer range is `^0.3.0`, the caldrix.js that reads a model's `chat_template.jinja`; the loop itself is unchanged.
+
+## 0.1.0 — 2026-10-30
+
+### Added
+
+- `Agent`: Aerix's turn loop on a caldrix.js `Model`, with `tool()`, hooks, limits and named endings.
+- `Agent` refuses a hand-built tool without `input`, and any own hooks key that looks like a misspelled hook (`before*`, `after*`, `on*`), with an `options` error; other own keys on a hooks object are instance state. `tool()` refuses the field names `__proto__`, `constructor` and `prototype`. A tool that returns `undefined` or `null` gives the model an empty result.

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,2 @@
+aerix.js (the npm package @caldrix-ai/aerix)
+Copyright 2026 Jyothsna Muttineni, for Caldrix GmbH (in formation)

package/README.md

@@ -1,3 +1,142 @@
-# Temporary Holding Version
+# aerix.js
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Aerix's turn loop in the browser: an agent with tools, hooks and named limits, running on a
+caldrix.js engine. On npm it is [`@caldrix-ai/aerix`](https://www.npmjs.com/package/@caldrix-ai/aerix).
+
+aerix.js loads nothing itself. You load a model with caldrix.js and hand its `Engine` to an `Agent`.
+The loop asks the engine for one turn at a time, runs the tools the turn calls, and feeds the results
+back until the model answers with a final or a limit is reached.
+
+## Install
+
+```sh
+npm install @caldrix-ai/caldrix @caldrix-ai/aerix
+```
+
+`@caldrix-ai/caldrix` is a peer dependency (`^0.3.0`, the caldrix.js that reads a model's `chat_template.jinja`).
+
+## Example
+
+```ts
+import { Caldrix } from "@caldrix-ai/caldrix";
+import { Agent, tool } from "@caldrix-ai/aerix";
+
+const engine = await Caldrix.load("smollm2-instruct");
+
+const weather = tool({
+  name: "weather",
+  description: "Today's forecast for a city.",
+  input: {
+    city: { type: "string", description: "City name", required: true },
+    unit: { type: "string", enum: ["c", "f"] },
+  },
+  run: async ({ city, unit }) => `Sunny in ${city}, 21°${unit ?? "c"}`,
+});
+
+const agent = new Agent({
+  model: engine,
+  instructions: "You are a travel helper. Use the tools to answer.",
+  tools: [weather],
+  limits: { turns: 8, retries: 2, maxTokens: 384, resultChars: 4000 },
+  generation: { temperature: 0 },
+  hooks: { beforeCall: (call) => (call.tool === "weather" ? undefined : { deny: "not allowed" }) },
+});
+
+const controller = new AbortController();
+for await (const ev of agent.run("Should I pack an umbrella for Lisbon?", { signal: controller.signal })) {
+  if (ev.type === "final") console.log(ev.text);
+}
+const { text } = await agent.ask("And for Porto?"); // the same conversation
+console.log(text);
+agent.reset();
+```
+
+## API
+
+The package exports `Agent`, `tool` and `AerixError`, and the types `AgentOptions`, `Limits`, `Hooks`,
+`AgentEvent`, `Call`, `EndReason`, `Model`, `Tool`, `ToolDef`, `Field` and `FieldType`.
+
+**`Model`** is `{ chat(messages, opts?): AsyncIterable<Delta> }` over caldrix.js's types. A caldrix.js
+`Engine` satisfies it.
+
+**`tool(def)`** defines a tool:
+
+- `name` matches `^[a-z][a-z0-9_]{0,63}$` and is unique in the agent (a duplicate is refused when the
+  agent is built).
+- `description` is the text the model sees.
+- `input` is a flat field map. Each field has a `type` (`string`, `number`, `integer` or `boolean`)
+  and an optional `description`, `required` and `enum`. An empty map means no input.
+- `run(input, { signal, callId })` returns a string, or a value that goes through `JSON.stringify`.
+  The input is checked against the fields before `run`; a failed check or a throw becomes the result
+  `error: …`, and a tool error never ends the run.
+
+**`new Agent(options)`** takes `AgentOptions`:
+
+- `model` (required), `instructions` (default `""`), `tools` (default none; then the only answer is
+  a final).
+- `limits`, each a named bound: `turns` (8, generations per run, retries included), `retries` (2,
+  extra attempts after a bad or cut turn), `maxTokens` (512, per generation) and `resultChars` (4000,
+  one tool result is cut to this with a note).
+- `generation`: caldrix.js's `GenerationOptions` without `maxTokens` and `constraint`, which aerix.js
+  sets.
+- `constrain` (default `true`): send the turn schema as the `constraint` of every generation. Set
+  `false` for a `Model` without constrained decoding; then only parse-and-retry applies.
+- `hooks`, each optional and awaited: `beforeCall(call)` may return `{ deny: reason }` (the result
+  becomes `refused: <reason>`) or `{ input }` (replaces the call's input); `afterCall(call, result)`
+  may return `{ result }`; `onFinal(text)` may return `{ continue: text }`, which gives the agent
+  another turn with that text as a user message, within `turns`.
+
+**`agent.run(prompt, { signal })`** yields `AgentEvent`s and continues the agent's conversation:
+
+- `{ type: "text", text }`: raw streamed model text.
+- `{ type: "usage", promptTokens, completionTokens }`: one per generation.
+- `{ type: "turn", turn, thought?, calls }`, then per call `{ type: "call", id, tool, input }` and
+  `{ type: "result", id, tool, text, error }`.
+- `{ type: "retry", turn, reason }`: a cut or bad turn is asked again.
+- Exactly one ending: `{ type: "final", text, thought? }`, or `{ type: "end", reason, message? }`
+  where `reason` is `"turns"`, `"retries"`, `"abort"` or `"error"` (an engine failure or a throwing
+  hook, with its message). An engine failure is this event, never a throw.
+
+**`agent.ask(prompt, { signal })`** runs to the end and resolves `{ text, events }` on a final; any
+other ending rejects with `AerixError` kind `end`, carrying `reason` and `events`.
+**`agent.reset()`** forgets the conversation. **`agent.messages`** is the conversation so far.
+
+One run at a time: a second concurrent `run` throws `AerixError` kind `busy`, and bad options throw
+kind `options`.
+
+## The turn contract
+
+Every turn is one JSON object, either `{"calls":[{"tool":"…","input":{…}}]}` or `{"final":"…"}`, with an
+optional `thought`. The system message states this contract and lists the tools; it is the same
+contract and the same tool rendering as Aerix's.
+
+Every turn is constrained (unless `constrain: false`): the engine decodes under a schema built from
+the tools, so a turn that ends on its own is a valid turn with a known tool and an input of the right
+shape, with one exception: an empty `calls` list passes the constraint, and parsing refuses it
+and retries. A turn cut by `maxTokens` before its JSON closes is dropped and asked again, shorter, as a
+retry. At most 8 calls of one turn are kept, a `thought` is cut at 600 characters, and calls run in
+order, one at a time.
+
+Each turn's prompt is the system message plus every earlier turn and result. The engine keeps what the
+previous generation processed, so a turn that only appends to the conversation prefills the new part;
+the done delta's `usage.cachedTokens` says how much was reused.
+
+## Not built
+
+- Per-option scores for routing (the browser engine returns `logprobs`; nothing here reads them).
+- Subagents and a verifier, compaction and a context tool, sessions kept in IndexedDB.
+
+## What has run
+
+- The unit tests, against a scripted fake `Model`: the turn parsing, the system rendering and the turn
+  schema (golden), the turn contract pinned to Aerix's, input checks, each hook, each ending and each limit.
+- One end-to-end test in Playwright's headless Chromium on the wasm tier: an `Agent` with one tool
+  on the built caldrix.js, loading a tiny test model whose output is noise, from a loopback server.
+  It checks that the engine receives the turn schema on every generation, that every retry follows a
+  cut turn, and that the run ends with a named outcome.
+
+Nothing more is claimed: no real model, no other browser or tier, and no quality or speed figure.
+
+## License
+
+aerix.js (the npm package `@caldrix-ai/aerix`) is under Apache-2.0 (`LICENSE`, `NOTICE`).

package/dist/index.d.ts

@@ -0,0 +1,150 @@
+import { ChatMessage, GenerateOptions, Delta, GenerationOptions } from '@caldrix-ai/caldrix';
+
+/** Why a run ended without a final. */
+type EndReason = "turns" | "retries" | "abort" | "error";
+/** One tool call of a turn. */
+interface Call {
+    id: string;
+    tool: string;
+    input: Record<string, unknown>;
+}
+/** One event of a run. Every run ends with exactly one `final` or `end`. */
+type AgentEvent = {
+    type: "text";
+    text: string;
+} | {
+    type: "usage";
+    promptTokens: number;
+    completionTokens: number;
+} | {
+    type: "turn";
+    turn: number;
+    thought?: string;
+    calls: Call[];
+} | {
+    type: "call";
+    id: string;
+    tool: string;
+    input: Record<string, unknown>;
+} | {
+    type: "result";
+    id: string;
+    tool: string;
+    text: string;
+    error: boolean;
+} | {
+    type: "retry";
+    turn: number;
+    reason: string;
+} | {
+    type: "final";
+    text: string;
+    thought?: string;
+} | {
+    type: "end";
+    reason: EndReason;
+    message?: string;
+};
+
+/** What the loop generates with. A caldrix.js `Engine` satisfies it. */
+interface Model {
+    chat(messages: ChatMessage[], opts?: GenerateOptions): AsyncIterable<Delta>;
+}
+
+type FieldType = "string" | "number" | "integer" | "boolean";
+interface Field {
+    type: FieldType;
+    description?: string;
+    required?: boolean;
+    enum?: readonly (string | number | boolean)[];
+}
+interface ToolDef<I> {
+    name: string;
+    description: string;
+    input: Record<string, Field>;
+    run(input: I, cx: {
+        signal: AbortSignal;
+        callId: string;
+    }): unknown | Promise<unknown>;
+}
+/** A defined tool: the frozen definition and its compiled input schema. */
+interface Tool extends Readonly<ToolDef<any>> {
+    readonly schema: object;
+}
+declare function tool<I = Record<string, unknown>>(def: ToolDef<I>): Tool;
+
+interface Limits {
+    /** Generations per run, retries and cut turns included. */
+    turns?: number;
+    /** Extra attempts after a bad or cut turn, per turn. */
+    retries?: number;
+    /** Tokens per generation. */
+    maxTokens?: number;
+    /** Characters of one tool result; the rest is cut with a note. */
+    resultChars?: number;
+}
+type Awaitable<T> = T | Promise<T>;
+type BeforeCall = void | {
+    deny: string;
+} | {
+    input: Record<string, unknown>;
+};
+type AfterCall = void | {
+    result: string;
+};
+type OnFinal = void | {
+    continue: string;
+};
+interface Hooks {
+    /** A deny becomes the result `refused: <reason>`; `input` replaces the call's input. */
+    beforeCall?(c: Call): Awaitable<BeforeCall>;
+    /** `result` replaces the tool's result. */
+    afterCall?(c: Call, result: string): Awaitable<AfterCall>;
+    /** `continue` gives the agent another turn with that text as a user message (bounded by `turns`). */
+    onFinal?(text: string): Awaitable<OnFinal>;
+}
+interface AgentOptions {
+    model: Model;
+    instructions?: string;
+    tools?: Tool[];
+    limits?: Limits;
+    generation?: Omit<GenerationOptions, "maxTokens" | "constraint">;
+    /** Send the turn schema as `constraint.json` on each generation (default `true`). */
+    constrain?: boolean;
+    hooks?: Hooks;
+}
+/** Runs Aerix's turn loop on a `Model`: one run at a time, over one conversation. */
+declare class Agent {
+    #private;
+    constructor(o: AgentOptions);
+    /** The conversation so far: the system message, then every prompt, turn and result. */
+    get messages(): readonly ChatMessage[];
+    /** Forgets the conversation (and restarts call ids at `c1`). */
+    reset(): void;
+    /**
+     * Runs the loop on `prompt`, continuing the conversation. Ends with exactly one `final` or `end`
+     * event; it throws only `AerixError` kind `busy` (a run is already going) or `options`.
+     */
+    run(prompt: string, o?: {
+        signal?: AbortSignal;
+    }): AsyncGenerator<AgentEvent, void, undefined>;
+    /** Runs to the end: resolves on a final, else rejects with `AerixError` kind `end`. */
+    ask(prompt: string, o?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        text: string;
+        events: AgentEvent[];
+    }>;
+}
+
+declare class AerixError extends Error {
+    readonly kind: "options" | "busy" | "end";
+    readonly reason?: EndReason;
+    readonly events?: AgentEvent[];
+    constructor(kind: "options" | "busy" | "end", message: string, extra?: {
+        reason?: EndReason;
+        events?: AgentEvent[];
+    });
+}
+
+export { AerixError, Agent, type AgentEvent, type AgentOptions, type Call, type EndReason, type Field, type FieldType, type Hooks, type Limits, type Model, type Tool, type ToolDef, tool };

package/dist/index.js

@@ -0,0 +1,544 @@
+// src/errors.ts
+var AerixError = class extends Error {
+  kind;
+  reason;
+  events;
+  constructor(kind, message2, extra = {}) {
+    super(message2);
+    this.name = "AerixError";
+    this.kind = kind;
+    if (extra.reason !== void 0) this.reason = extra.reason;
+    if (extra.events !== void 0) this.events = extra.events;
+  }
+};
+
+// src/turn_contract.ts
+var TURN_CONTRACT = `Every turn you answer with exactly one JSON object and nothing else. There are two shapes.
+
+To use tools, answer: {"calls":[{"tool":"read","input":{"path":"src/main.rs"}}]}
+Each call has a "tool" name and an "input" object. You may list several calls in one turn. They run in order, except agent calls, which run at the same time.
+
+When the task is done, answer: {"final":"what you did and what you found"}
+`;
+
+// src/render.ts
+function typeLabel(p) {
+  if (Array.isArray(p.enum)) {
+    return `one of ${p.enum.map(String).join("|")}`;
+  }
+  return typeof p.type === "string" ? p.type : "any";
+}
+function fieldList(t) {
+  const names = Object.keys(t.input);
+  if (names.length === 0) return "none (pass an empty object)";
+  const req = (n) => t.input[n]?.required === true;
+  names.sort((a, b) => Number(!req(a)) - Number(!req(b)) || (a < b ? -1 : a > b ? 1 : 0));
+  return names.map((n) => {
+    const kind = typeLabel(t.input[n]);
+    return req(n) ? `${n} (${kind}, required)` : `${n} (${kind})`;
+  }).join(", ");
+}
+function describe(tools) {
+  if (tools.length === 0) return "(no tools; answer with a final)";
+  return tools.map((t) => `## ${t.name}
+${t.description}
+
+Input: ${fieldList(t)}`).join("\n\n");
+}
+function systemText(instructions, tools) {
+  return `${instructions.trimEnd()}
+
+# Turns
+${TURN_CONTRACT.trimEnd()}
+
+# Tools
+${describe(tools)}`;
+}
+
+// src/schema.ts
+var MAX_THOUGHT = 600;
+function inputSchema(input) {
+  const properties = {};
+  const required = [];
+  for (const [name, f] of Object.entries(input)) {
+    const p = { type: f.type };
+    if (f.description !== void 0) p.description = f.description;
+    if (f.enum !== void 0) p.enum = [...f.enum];
+    properties[name] = p;
+    if (f.required === true) required.push(name);
+  }
+  return { type: "object", properties, required, additionalProperties: false };
+}
+function envelopeSchema(tools) {
+  return {
+    oneOf: tools.map((t) => ({
+      type: "object",
+      properties: {
+        tool: { enum: [t.name], description: "the tool to call" },
+        input: t.schema
+      },
+      required: ["tool", "input"],
+      additionalProperties: false
+    }))
+  };
+}
+function turnSchema(tools) {
+  const thought = { type: "string", maxLength: MAX_THOUGHT };
+  const finalBranch = {
+    type: "object",
+    properties: { thought, final: { type: "string" } },
+    required: ["final"],
+    additionalProperties: false
+  };
+  if (tools.length === 0) return finalBranch;
+  return {
+    oneOf: [
+      {
+        type: "object",
+        properties: { thought, calls: { type: "array", items: envelopeSchema(tools) } },
+        required: ["calls"],
+        additionalProperties: false
+      },
+      finalBranch
+    ]
+  };
+}
+
+// src/tool.ts
+var NAME = /^[a-z][a-z0-9_]{0,63}$/;
+var RESERVED = ["__proto__", "constructor", "prototype"];
+var TYPES = ["string", "number", "integer", "boolean"];
+var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function tool(def) {
+  if (!isObject(def)) throw new AerixError("options", "a tool definition must be an object");
+  if (typeof def.name !== "string" || !NAME.test(def.name)) {
+    throw new AerixError("options", `tool name ${JSON.stringify(def.name)} must match ${NAME.source}`);
+  }
+  if (typeof def.description !== "string") {
+    throw new AerixError("options", `tool ${def.name}: description must be a string`);
+  }
+  if (typeof def.run !== "function") {
+    throw new AerixError("options", `tool ${def.name}: run must be a function`);
+  }
+  if (!isObject(def.input)) {
+    throw new AerixError("options", `tool ${def.name}: input must be a field map (an object)`);
+  }
+  const proto = Object.getPrototypeOf(def.input);
+  if (proto !== Object.prototype && proto !== null) {
+    throw new AerixError(
+      "options",
+      `tool ${def.name}: input has a prototype of its own (a literal __proto__ key sets it instead of adding a field)`
+    );
+  }
+  const input = {};
+  for (const [field, f] of Object.entries(def.input)) {
+    if (RESERVED.includes(field)) {
+      throw new AerixError("options", `tool ${def.name}: field name ${field} is reserved`);
+    }
+    if (!isObject(f)) throw new AerixError("options", `tool ${def.name}: field ${field} must be an object`);
+    if (!TYPES.includes(f.type)) {
+      throw new AerixError("options", `tool ${def.name}: field ${field} has an unknown type`);
+    }
+    for (const v of f.enum ?? []) {
+      const ok = f.type === "integer" ? Number.isInteger(v) : f.type === "number" ? typeof v === "number" && Number.isFinite(v) : typeof v === f.type;
+      if (!ok) {
+        throw new AerixError("options", `tool ${def.name}: field ${field} has an enum value that is not a ${f.type}`);
+      }
+    }
+    input[field] = Object.freeze({ ...f, ...f.enum ? { enum: Object.freeze([...f.enum]) } : {} });
+  }
+  Object.freeze(input);
+  return Object.freeze({
+    name: def.name,
+    description: def.description,
+    input,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    run: def.run,
+    schema: inputSchema(input)
+  });
+}
+function checkInput(t, input) {
+  for (const key of Object.keys(input)) {
+    if (!Object.hasOwn(t.input, key)) return `unknown field ${key}`;
+  }
+  for (const [name, f] of Object.entries(t.input)) {
+    const v = Object.hasOwn(input, name) ? input[name] : void 0;
+    if (v === void 0 || v === null) {
+      if (f.required === true) return `missing required field ${name}`;
+      continue;
+    }
+    const ok = f.type === "integer" ? typeof v === "number" && Number.isInteger(v) : typeof v === f.type && (f.type !== "number" || Number.isFinite(v));
+    if (!ok) return `field ${name} must be ${f.type === "integer" ? "an integer" : `a ${f.type}`}`;
+    if (f.enum !== void 0 && !f.enum.includes(v)) {
+      return `field ${name} must be one of ${f.enum.map(String).join("|")}`;
+    }
+  }
+  return null;
+}
+
+// src/turn.ts
+var MAX_CALLS = 8;
+var bad = (error) => ({ ok: false, error });
+var isObject2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function parseTurn(text, tools, nextId) {
+  let value;
+  try {
+    value = JSON.parse(text.trim());
+  } catch (e) {
+    return bad(`the answer is not valid JSON (${e instanceof Error ? e.message : String(e)})`);
+  }
+  if (!isObject2(value)) return bad("the answer must be one JSON object");
+  const has = (k) => Object.hasOwn(value, k);
+  let thought;
+  const raw = has("thought") ? value.thought : void 0;
+  if (raw === void 0 || raw === null) {
+    thought = void 0;
+  } else if (typeof raw === "string") {
+    const chars = Array.from(raw);
+    thought = chars.length > MAX_THOUGHT ? `${chars.slice(0, MAX_THOUGHT).join("")} (thought cut to ${MAX_THOUGHT} characters)` : raw;
+  } else {
+    return bad("thought must be a string");
+  }
+  if (has("calls")) {
+    const items = value.calls;
+    if (!Array.isArray(items)) return bad("calls must be an array");
+    if (items.length === 0) return bad("calls is empty; give at least one call, or a final");
+    const parsed = [];
+    for (const [i, item] of items.entries()) {
+      const name = isObject2(item) && typeof item.tool === "string" ? item.tool : void 0;
+      if (name === void 0) return bad(`call ${i + 1} needs a tool name in "tool"`);
+      if (!tools.some((t) => t.name === name)) return bad(`unknown tool ${name}`);
+      const input = item.input;
+      if (!isObject2(input)) return bad(`the input of call ${i + 1} (${name}) must be an object`);
+      parsed.push({ tool: name, input });
+    }
+    const total = parsed.length;
+    if (total > MAX_CALLS) {
+      parsed.length = MAX_CALLS;
+      const note = `(${MAX_CALLS} of ${total} calls kept)`;
+      thought = thought !== void 0 && thought !== "" ? `${thought} ${note}` : note;
+    }
+    const calls = parsed.map((c) => ({ id: `c${nextId.n++}`, ...c }));
+    return { ok: true, turn: { kind: "calls", ...thought !== void 0 && { thought }, calls } };
+  }
+  if (has("final")) {
+    if (typeof value.final !== "string") return bad("final must be a string");
+    return {
+      ok: true,
+      turn: { kind: "final", ...thought !== void 0 && { thought }, text: value.final }
+    };
+  }
+  return bad(`expected calls or final, found keys [${Object.keys(value).sort().join(", ")}]`);
+}
+
+// src/agent.ts
+var DEFAULT_LIMITS = { turns: 8, retries: 2, maxTokens: 512, resultChars: 4e3 };
+var LIMIT_MIN = { turns: 1, retries: 0, maxTokens: 1, resultChars: 1 };
+var CUT_NOTE = "Your last turn hit the token limit before the JSON closed; answer again, shorter.";
+var badNote = (error) => `Your last turn was not valid: ${error}. Answer again as JSON.`;
+var isObject3 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var message = (e) => e instanceof Error ? e.message : String(e);
+var msg = (role, content) => Object.freeze({ role, content });
+var refuse = (text) => new AerixError("options", text);
+function checkLimits(limits) {
+  if (limits === void 0) return { ...DEFAULT_LIMITS };
+  if (!isObject3(limits)) throw refuse("limits must be an object");
+  const out = { ...DEFAULT_LIMITS };
+  for (const [k, v] of Object.entries(limits)) {
+    if (!Object.hasOwn(DEFAULT_LIMITS, k)) throw refuse(`unknown limit ${k}`);
+    if (v === void 0) continue;
+    const min = LIMIT_MIN[k];
+    if (typeof v !== "number" || !Number.isInteger(v) || v < min) {
+      throw refuse(`limits.${k} must be an integer of at least ${min}`);
+    }
+    out[k] = v;
+  }
+  return out;
+}
+function checkTools(tools) {
+  if (tools === void 0) return [];
+  if (!Array.isArray(tools)) throw refuse("tools must be an array");
+  const names = /* @__PURE__ */ new Set();
+  for (const t of tools) {
+    if (!isObject3(t) || typeof t.name !== "string" || typeof t.run !== "function" || !isObject3(t.schema)) {
+      throw refuse("each tool must be made with tool()");
+    }
+    if (!isObject3(t.input)) throw refuse(`tool ${t.name}: input must be a field map (an object)`);
+    if (names.has(t.name)) throw refuse(`two tools are named ${t.name}`);
+    names.add(t.name);
+  }
+  return Object.freeze([...tools]);
+}
+function checkGeneration(generation) {
+  if (generation === void 0) return {};
+  if (!isObject3(generation)) throw refuse("generation must be an object");
+  for (const k of ["maxTokens", "constraint", "signal"]) {
+    if (Object.hasOwn(generation, k)) {
+      throw refuse(`generation.${k} is set by the agent (use limits.maxTokens, constrain or run's signal)`);
+    }
+  }
+  return { ...generation };
+}
+var HOOK_NAMES = ["beforeCall", "afterCall", "onFinal"];
+function checkHooks(hooks) {
+  if (hooks === void 0) return {};
+  if (!isObject3(hooks)) throw refuse("hooks must be an object");
+  for (const k of Object.keys(hooks)) {
+    if (!HOOK_NAMES.includes(k) && /^(before|after|on)[A-Z]/.test(k)) {
+      throw refuse(`unknown hook ${k} (hooks are ${HOOK_NAMES.join(", ")})`);
+    }
+  }
+  const out = {};
+  for (const k of HOOK_NAMES) {
+    const f = hooks[k];
+    if (f === void 0) continue;
+    if (typeof f !== "function") throw refuse(`hooks.${k} must be a function`);
+    out[k] = f.bind(hooks);
+  }
+  return out;
+}
+function capResult(text, cap) {
+  if (text.length <= cap) return text;
+  const chars = Array.from(text);
+  if (chars.length <= cap) return text;
+  return `${chars.slice(0, cap).join("")}
+[result cut to ${cap} of ${chars.length} characters]`;
+}
+var resultText = (v) => typeof v === "string" ? v : v === void 0 || v === null ? "" : JSON.stringify(v) ?? String(v);
+var ABORTED = /* @__PURE__ */ Symbol("aborted");
+async function untilAbort(fn, signal) {
+  let onAbort = () => {
+  };
+  const aborted = new Promise((resolve) => {
+    onAbort = () => resolve(ABORTED);
+    if (signal.aborted) onAbort();
+    else signal.addEventListener("abort", onAbort, { once: true });
+  });
+  const ran = Promise.resolve().then(fn).then(
+    (value) => ({ value }),
+    (e) => ({ thrown: e })
+  );
+  try {
+    return await Promise.race([ran, aborted]);
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+  }
+}
+async function hook(fn, signal) {
+  if (fn === void 0) return void 0;
+  const out = await untilAbort(fn, signal);
+  if (out === ABORTED) return ABORTED;
+  if ("thrown" in out) throw out.thrown;
+  return out.value;
+}
+var Agent = class {
+  #model;
+  #tools;
+  #limits;
+  #generation;
+  #constraint;
+  #hooks;
+  #system;
+  #messages;
+  #nextId = { n: 1 };
+  #busy = false;
+  constructor(o) {
+    if (!isObject3(o)) throw refuse("options must be an object");
+    if (!isObject3(o.model) || typeof o.model.chat !== "function") {
+      throw refuse("model must have a chat method (a caldrix.js Engine does)");
+    }
+    if (o.instructions !== void 0 && typeof o.instructions !== "string") {
+      throw refuse("instructions must be a string");
+    }
+    if (o.constrain !== void 0 && typeof o.constrain !== "boolean") throw refuse("constrain must be a boolean");
+    this.#model = o.model;
+    this.#tools = checkTools(o.tools);
+    this.#limits = checkLimits(o.limits);
+    this.#generation = checkGeneration(o.generation);
+    this.#hooks = checkHooks(o.hooks);
+    this.#constraint = o.constrain === false ? void 0 : { json: turnSchema(this.#tools) };
+    this.#system = msg("system", systemText(o.instructions ?? "", this.#tools));
+    this.#messages = [this.#system];
+  }
+  /** The conversation so far: the system message, then every prompt, turn and result. */
+  get messages() {
+    return Object.freeze([...this.#messages]);
+  }
+  /** Forgets the conversation (and restarts call ids at `c1`). */
+  reset() {
+    if (this.#busy) throw new AerixError("busy", "a run is going on this agent");
+    this.#messages = [this.#system];
+    this.#nextId = { n: 1 };
+  }
+  /**
+   * Runs the loop on `prompt`, continuing the conversation. Ends with exactly one `final` or `end`
+   * event; it throws only `AerixError` kind `busy` (a run is already going) or `options`.
+   */
+  async *run(prompt, o = {}) {
+    if (this.#busy) throw new AerixError("busy", "a run is already going on this agent");
+    if (typeof prompt !== "string") throw refuse("prompt must be a string");
+    const signal = o?.signal;
+    if (signal !== void 0 && (!isObject3(signal) || typeof signal.addEventListener !== "function")) {
+      throw refuse("signal must be an AbortSignal");
+    }
+    this.#busy = true;
+    try {
+      yield* this.#loop(prompt, signal ?? new AbortController().signal);
+    } finally {
+      this.#busy = false;
+    }
+  }
+  /** Runs to the end: resolves on a final, else rejects with `AerixError` kind `end`. */
+  async ask(prompt, o = {}) {
+    const events = [];
+    for await (const ev of this.run(prompt, o)) {
+      events.push(ev);
+      if (ev.type === "final") return { text: ev.text, events };
+      if (ev.type === "end") {
+        throw new AerixError("end", ev.message ?? `the run ended without a final (${ev.reason})`, {
+          reason: ev.reason,
+          events
+        });
+      }
+    }
+    throw new AerixError("end", "the run ended without a final", { events });
+  }
+  async *#loop(prompt, signal) {
+    const msgs = this.#messages;
+    const limits = this.#limits;
+    msgs.push(msg("user", prompt));
+    let turnStart = msgs.length;
+    let done = false;
+    const end = (reason, text) => {
+      done = true;
+      msgs.length = turnStart;
+      return text === void 0 ? { type: "end", reason } : { type: "end", reason, message: text };
+    };
+    const spent = () => end("turns", `the turn budget (${limits.turns}) is spent`);
+    let turn = 0;
+    try {
+      for (; ; ) {
+        turnStart = msgs.length;
+        let attempt = 0;
+        let text = "";
+        let parsed;
+        for (; ; ) {
+          if (signal.aborted) return yield end("abort");
+          if (turn >= limits.turns) return yield spent();
+          turn++;
+          const opts = {
+            ...this.#generation,
+            maxTokens: limits.maxTokens,
+            ...this.#constraint && { constraint: this.#constraint },
+            signal
+          };
+          text = "";
+          let finish;
+          for await (const d of this.#model.chat([...msgs], opts)) {
+            if (typeof d.text === "string" && d.text !== "") {
+              text += d.text;
+              yield { type: "text", text: d.text };
+            }
+            if (d.done) {
+              finish = d.finishReason;
+              if (d.usage) {
+                const { promptTokens, completionTokens } = d.usage;
+                yield { type: "usage", promptTokens, completionTokens };
+              }
+              break;
+            }
+          }
+          if (signal.aborted || finish === "abort") return yield end("abort");
+          parsed = parseTurn(text, this.#tools, this.#nextId);
+          if (parsed.ok) break;
+          if (turn >= limits.turns) return yield spent();
+          if (attempt >= limits.retries) {
+            return yield end("retries", `no valid turn after ${limits.retries} retries: ${parsed.error}`);
+          }
+          attempt++;
+          if (finish === "length") {
+            yield { type: "retry", turn, reason: "the turn hit the token limit before the JSON closed" };
+            msgs.push(msg("user", CUT_NOTE));
+          } else {
+            yield { type: "retry", turn, reason: parsed.error };
+            msgs.push(msg("assistant", text), msg("user", badNote(parsed.error)));
+          }
+        }
+        msgs.length = turnStart;
+        msgs.push(msg("assistant", text));
+        const t = parsed.turn;
+        if (t.kind === "final") {
+          const onFinal = this.#hooks.onFinal;
+          const next = await hook(onFinal && (() => onFinal(t.text)), signal);
+          if (next === ABORTED) return yield end("abort");
+          if (isObject3(next) && typeof next.continue === "string") {
+            msgs.push(msg("user", next.continue));
+            continue;
+          }
+          done = true;
+          return yield { type: "final", text: t.text, ...t.thought !== void 0 && { thought: t.thought } };
+        }
+        yield {
+          type: "turn",
+          turn,
+          ...t.thought !== void 0 && { thought: t.thought },
+          calls: t.calls.map((c) => ({ ...c, input: { ...c.input } }))
+        };
+        for (const c of t.calls) {
+          if (signal.aborted) return yield end("abort");
+          if ((yield* this.#call(c, signal)) === ABORTED) return yield end("abort");
+        }
+      }
+    } catch (e) {
+      yield signal.aborted ? end("abort") : end("error", message(e));
+    } finally {
+      if (!done) msgs.length = turnStart;
+    }
+  }
+  /** One call: the hooks, the input check and the tool, then its result appended to the conversation. */
+  async *#call(c, signal) {
+    const t = this.#tools.find((x) => x.name === c.tool);
+    let input = c.input;
+    const { beforeCall, afterCall } = this.#hooks;
+    const before = await hook(beforeCall && (() => beforeCall({ ...c, input: { ...input } })), signal);
+    if (before === ABORTED) return ABORTED;
+    let text;
+    let error = true;
+    if (isObject3(before) && typeof before.deny === "string") {
+      yield { type: "call", id: c.id, tool: c.tool, input: { ...input } };
+      text = `refused: ${before.deny}`;
+    } else {
+      if (isObject3(before) && isObject3(before.input)) input = { ...before.input };
+      yield { type: "call", id: c.id, tool: c.tool, input: { ...input } };
+      const bad2 = checkInput(t, input);
+      if (bad2 !== null) {
+        text = `error: ${bad2}`;
+      } else {
+        const cx = { signal, callId: c.id };
+        const out = await untilAbort(async () => resultText(await t.run(input, cx)), signal);
+        if (out === ABORTED || signal.aborted) return ABORTED;
+        if ("value" in out) {
+          text = out.value;
+          error = false;
+        } else {
+          text = `error: ${message(out.thrown)}`;
+        }
+        const ran = text;
+        const after = await hook(afterCall && (() => afterCall({ ...c, input: { ...input } }, ran)), signal);
+        if (after === ABORTED) return ABORTED;
+        if (isObject3(after) && typeof after.result === "string") text = after.result;
+      }
+    }
+    text = capResult(text, this.#limits.resultChars);
+    this.#messages.push(msg("user", `[${c.tool} ${c.id}]
+${text}`));
+    yield { type: "result", id: c.id, tool: c.tool, text, error };
+    return void 0;
+  }
+};
+export {
+  AerixError,
+  Agent,
+  tool
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts","../src/turn_contract.ts","../src/render.ts","../src/schema.ts","../src/tool.ts","../src/turn.ts","../src/agent.ts"],"sourcesContent":["import type { AgentEvent, EndReason } from \"./events.js\";\n\nexport class AerixError extends Error {\n  readonly kind: \"options\" | \"busy\" | \"end\";\n  readonly reason?: EndReason;\n  readonly events?: AgentEvent[];\n\n  constructor(\n    kind: \"options\" | \"busy\" | \"end\",\n    message: string,\n    extra: { reason?: EndReason; events?: AgentEvent[] } = {},\n  ) {\n    super(message);\n    this.name = \"AerixError\";\n    this.kind = kind;\n    if (extra.reason !== undefined) this.reason = extra.reason;\n    if (extra.events !== undefined) this.events = extra.events;\n  }\n}\n","// Verbatim copy of aerix/crates/aerix-core/src/turn_contract.md; tests/unit/turn_contract.test.ts fails on drift.\nexport const TURN_CONTRACT = `Every turn you answer with exactly one JSON object and nothing else. There are two shapes.\n\nTo use tools, answer: {\"calls\":[{\"tool\":\"read\",\"input\":{\"path\":\"src/main.rs\"}}]}\nEach call has a \"tool\" name and an \"input\" object. You may list several calls in one turn. They run in order, except agent calls, which run at the same time.\n\nWhen the task is done, answer: {\"final\":\"what you did and what you found\"}\n`;\n","import { TURN_CONTRACT } from \"./turn_contract.js\";\nimport type { Tool } from \"./tool.js\";\n\ntype Prop = { type?: unknown; enum?: unknown; items?: Prop };\n\n/**\n * aerix-core's type_label: an enum reads `one of a|b`, else the type. Non-string enum values render\n * with `String(v)` (`one of 1|2`): a deliberate departure, since aerix-core never has them.\n */\nfunction typeLabel(p: Prop): string {\n  if (Array.isArray(p.enum)) {\n    return `one of ${p.enum.map(String).join(\"|\")}`;\n  }\n  return typeof p.type === \"string\" ? p.type : \"any\";\n}\n\n/** `city (string, required), unit (string)`: required fields first, then the rest by name. */\nfunction fieldList(t: Tool): string {\n  const names = Object.keys(t.input);\n  if (names.length === 0) return \"none (pass an empty object)\";\n  const req = (n: string) => t.input[n]?.required === true;\n  names.sort((a, b) => Number(!req(a)) - Number(!req(b)) || (a < b ? -1 : a > b ? 1 : 0));\n  return names\n    .map((n) => {\n      const kind = typeLabel(t.input[n] as Prop);\n      return req(n) ? `${n} (${kind}, required)` : `${n} (${kind})`;\n    })\n    .join(\", \");\n}\n\nfunction describe(tools: readonly Tool[]): string {\n  if (tools.length === 0) return \"(no tools; answer with a final)\";\n  return tools.map((t) => `## ${t.name}\\n${t.description}\\n\\nInput: ${fieldList(t)}`).join(\"\\n\\n\");\n}\n\n/** The system message: instructions, the turn contract, then the tools. */\nexport function systemText(instructions: string, tools: readonly Tool[]): string {\n  return `${instructions.trimEnd()}\\n\\n# Turns\\n${TURN_CONTRACT.trimEnd()}\\n\\n# Tools\\n${describe(tools)}`;\n}\n","import type { Field, Tool } from \"./tool.js\";\n\nexport const MAX_THOUGHT = 600;\n\n/** The JSON schema of a flat field map, inside the engine's subset. */\nexport function inputSchema(input: Record<string, Field>): object {\n  const properties: Record<string, object> = {};\n  const required: string[] = [];\n  for (const [name, f] of Object.entries(input)) {\n    const p: Record<string, unknown> = { type: f.type };\n    if (f.description !== undefined) p.description = f.description;\n    if (f.enum !== undefined) p.enum = [...f.enum];\n    properties[name] = p;\n    if (f.required === true) required.push(name);\n  }\n  return { type: \"object\", properties, required, additionalProperties: false };\n}\n\n/** `oneOf` over the tools: `{tool: {enum: [name]}, input: <schema>}` (aerix-core's envelope_schema). */\nfunction envelopeSchema(tools: readonly Tool[]): object {\n  return {\n    oneOf: tools.map((t) => ({\n      type: \"object\",\n      properties: {\n        tool: { enum: [t.name], description: \"the tool to call\" },\n        input: t.schema,\n      },\n      required: [\"tool\", \"input\"],\n      additionalProperties: false,\n    })),\n  };\n}\n\n/** The schema of a turn: calls to the tools, or a final. With no tools, the final alone. */\nexport function turnSchema(tools: readonly Tool[]): Record<string, unknown> {\n  const thought = { type: \"string\", maxLength: MAX_THOUGHT };\n  const finalBranch = {\n    type: \"object\",\n    properties: { thought, final: { type: \"string\" } },\n    required: [\"final\"],\n    additionalProperties: false,\n  };\n  if (tools.length === 0) return finalBranch;\n  return {\n    oneOf: [\n      {\n        type: \"object\",\n        properties: { thought, calls: { type: \"array\", items: envelopeSchema(tools) } },\n        required: [\"calls\"],\n        additionalProperties: false,\n      },\n      finalBranch,\n    ],\n  };\n}\n","import { AerixError } from \"./errors.js\";\nimport { inputSchema } from \"./schema.js\";\n\nexport type FieldType = \"string\" | \"number\" | \"integer\" | \"boolean\";\n\nexport interface Field {\n  type: FieldType;\n  description?: string;\n  required?: boolean;\n  enum?: readonly (string | number | boolean)[];\n}\n\nexport interface ToolDef<I> {\n  name: string;\n  description: string;\n  input: Record<string, Field>;\n  run(input: I, cx: { signal: AbortSignal; callId: string }): unknown | Promise<unknown>;\n}\n\n/** A defined tool: the frozen definition and its compiled input schema. */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport interface Tool extends Readonly<ToolDef<any>> {\n  readonly schema: object;\n}\n\nconst NAME = /^[a-z][a-z0-9_]{0,63}$/;\nconst RESERVED: readonly string[] = [\"__proto__\", \"constructor\", \"prototype\"];\nconst TYPES: readonly string[] = [\"string\", \"number\", \"integer\", \"boolean\"];\n\nconst isObject = (v: unknown): v is object => typeof v === \"object\" && v !== null && !Array.isArray(v);\n\nexport function tool<I = Record<string, unknown>>(def: ToolDef<I>): Tool {\n  if (!isObject(def)) throw new AerixError(\"options\", \"a tool definition must be an object\");\n  if (typeof def.name !== \"string\" || !NAME.test(def.name)) {\n    throw new AerixError(\"options\", `tool name ${JSON.stringify(def.name)} must match ${NAME.source}`);\n  }\n  if (typeof def.description !== \"string\") {\n    throw new AerixError(\"options\", `tool ${def.name}: description must be a string`);\n  }\n  if (typeof def.run !== \"function\") {\n    throw new AerixError(\"options\", `tool ${def.name}: run must be a function`);\n  }\n  if (!isObject(def.input)) {\n    throw new AerixError(\"options\", `tool ${def.name}: input must be a field map (an object)`);\n  }\n  const proto: unknown = Object.getPrototypeOf(def.input);\n  if (proto !== Object.prototype && proto !== null) {\n    throw new AerixError(\n      \"options\",\n      `tool ${def.name}: input has a prototype of its own (a literal __proto__ key sets it instead of adding a field)`,\n    );\n  }\n  const input: Record<string, Field> = {};\n  for (const [field, f] of Object.entries(def.input)) {\n    if (RESERVED.includes(field)) {\n      throw new AerixError(\"options\", `tool ${def.name}: field name ${field} is reserved`);\n    }\n    if (!isObject(f)) throw new AerixError(\"options\", `tool ${def.name}: field ${field} must be an object`);\n    if (!TYPES.includes(f.type)) {\n      throw new AerixError(\"options\", `tool ${def.name}: field ${field} has an unknown type`);\n    }\n    for (const v of f.enum ?? []) {\n      const ok =\n        f.type === \"integer\"\n          ? Number.isInteger(v)\n          : f.type === \"number\"\n            ? typeof v === \"number\" && Number.isFinite(v)\n            : typeof v === f.type;\n      if (!ok) {\n        throw new AerixError(\"options\", `tool ${def.name}: field ${field} has an enum value that is not a ${f.type}`);\n      }\n    }\n    input[field] = Object.freeze({ ...f, ...(f.enum ? { enum: Object.freeze([...f.enum]) } : {}) });\n  }\n  Object.freeze(input);\n  return Object.freeze({\n    name: def.name,\n    description: def.description,\n    input,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    run: def.run as ToolDef<any>[\"run\"],\n    schema: inputSchema(input),\n  });\n}\n\n/** The error text naming the offending field, or null when the input fits the tool's fields. */\nexport function checkInput(t: Tool, input: Record<string, unknown>): string | null {\n  for (const key of Object.keys(input)) {\n    if (!Object.hasOwn(t.input, key)) return `unknown field ${key}`;\n  }\n  for (const [name, f] of Object.entries(t.input)) {\n    const v = Object.hasOwn(input, name) ? input[name] : undefined;\n    if (v === undefined || v === null) {\n      if (f.required === true) return `missing required field ${name}`;\n      continue;\n    }\n    const ok =\n      f.type === \"integer\"\n        ? typeof v === \"number\" && Number.isInteger(v)\n        : typeof v === f.type && (f.type !== \"number\" || Number.isFinite(v));\n    if (!ok) return `field ${name} must be ${f.type === \"integer\" ? \"an integer\" : `a ${f.type}`}`;\n    if (f.enum !== undefined && !f.enum.includes(v as string | number | boolean)) {\n      return `field ${name} must be one of ${f.enum.map(String).join(\"|\")}`;\n    }\n  }\n  return null;\n}\n","import { MAX_THOUGHT } from \"./schema.js\";\nimport type { Tool } from \"./tool.js\";\n\nexport { MAX_THOUGHT };\n/** A turn names at most this many calls; the rest are dropped with a note. */\nexport const MAX_CALLS = 8;\n\nexport type Turn =\n  | {\n      kind: \"calls\";\n      thought?: string;\n      calls: { id: string; tool: string; input: Record<string, unknown> }[];\n    }\n  | { kind: \"final\"; thought?: string; text: string };\n\ntype Parsed = { ok: true; turn: Turn } | { ok: false; error: string };\nconst bad = (error: string): Parsed => ({ ok: false, error });\nconst isObject = (v: unknown): v is Record<string, unknown> =>\n  typeof v === \"object\" && v !== null && !Array.isArray(v);\n\n/**\n * Reads one turn (aerix-core's parse_turn, check for check). Call ids (`c<n>`) are taken from\n * `nextId.n` only when the turn parses.\n */\nexport function parseTurn(text: string, tools: readonly Tool[], nextId: { n: number }): Parsed {\n  let value: unknown;\n  try {\n    value = JSON.parse(text.trim());\n  } catch (e) {\n    return bad(`the answer is not valid JSON (${e instanceof Error ? e.message : String(e)})`);\n  }\n  if (!isObject(value)) return bad(\"the answer must be one JSON object\");\n  const has = (k: string) => Object.hasOwn(value, k);\n\n  let thought: string | undefined;\n  const raw = has(\"thought\") ? value.thought : undefined;\n  if (raw === undefined || raw === null) {\n    thought = undefined;\n  } else if (typeof raw === \"string\") {\n    const chars = Array.from(raw);\n    thought =\n      chars.length > MAX_THOUGHT\n        ? `${chars.slice(0, MAX_THOUGHT).join(\"\")} (thought cut to ${MAX_THOUGHT} characters)`\n        : raw;\n  } else {\n    return bad(\"thought must be a string\");\n  }\n\n  if (has(\"calls\")) {\n    const items = value.calls;\n    if (!Array.isArray(items)) return bad(\"calls must be an array\");\n    if (items.length === 0) return bad(\"calls is empty; give at least one call, or a final\");\n    const parsed: { tool: string; input: Record<string, unknown> }[] = [];\n    for (const [i, item] of items.entries()) {\n      const name = isObject(item) && typeof item.tool === \"string\" ? item.tool : undefined;\n      if (name === undefined) return bad(`call ${i + 1} needs a tool name in \"tool\"`);\n      if (!tools.some((t) => t.name === name)) return bad(`unknown tool ${name}`);\n      const input = (item as Record<string, unknown>).input;\n      if (!isObject(input)) return bad(`the input of call ${i + 1} (${name}) must be an object`);\n      parsed.push({ tool: name, input });\n    }\n    const total = parsed.length;\n    if (total > MAX_CALLS) {\n      parsed.length = MAX_CALLS;\n      const note = `(${MAX_CALLS} of ${total} calls kept)`;\n      thought = thought !== undefined && thought !== \"\" ? `${thought} ${note}` : note;\n    }\n    const calls = parsed.map((c) => ({ id: `c${nextId.n++}`, ...c }));\n    return { ok: true, turn: { kind: \"calls\", ...(thought !== undefined && { thought }), calls } };\n  }\n  if (has(\"final\")) {\n    if (typeof value.final !== \"string\") return bad(\"final must be a string\");\n    return {\n      ok: true,\n      turn: { kind: \"final\", ...(thought !== undefined && { thought }), text: value.final },\n    };\n  }\n  return bad(`expected calls or final, found keys [${Object.keys(value).sort().join(\", \")}]`);\n}\n","import type { ChatMessage, GenerateOptions, GenerationOptions } from \"@caldrix-ai/caldrix\";\nimport { AerixError } from \"./errors.js\";\nimport type { AgentEvent, Call, EndReason } from \"./events.js\";\nimport type { Model } from \"./model.js\";\nimport { systemText } from \"./render.js\";\nimport { turnSchema } from \"./schema.js\";\nimport { checkInput, type Tool } from \"./tool.js\";\nimport { parseTurn } from \"./turn.js\";\n\nexport interface Limits {\n  /** Generations per run, retries and cut turns included. */\n  turns?: number;\n  /** Extra attempts after a bad or cut turn, per turn. */\n  retries?: number;\n  /** Tokens per generation. */\n  maxTokens?: number;\n  /** Characters of one tool result; the rest is cut with a note. */\n  resultChars?: number;\n}\n\ntype Awaitable<T> = T | Promise<T>;\ntype BeforeCall = void | { deny: string } | { input: Record<string, unknown> };\ntype AfterCall = void | { result: string };\ntype OnFinal = void | { continue: string };\n\nexport interface Hooks {\n  /** A deny becomes the result `refused: <reason>`; `input` replaces the call's input. */\n  beforeCall?(c: Call): Awaitable<BeforeCall>;\n  /** `result` replaces the tool's result. */\n  afterCall?(c: Call, result: string): Awaitable<AfterCall>;\n  /** `continue` gives the agent another turn with that text as a user message (bounded by `turns`). */\n  onFinal?(text: string): Awaitable<OnFinal>;\n}\n\nexport interface AgentOptions {\n  model: Model;\n  instructions?: string;\n  tools?: Tool[];\n  limits?: Limits;\n  generation?: Omit<GenerationOptions, \"maxTokens\" | \"constraint\">;\n  /** Send the turn schema as `constraint.json` on each generation (default `true`). */\n  constrain?: boolean;\n  hooks?: Hooks;\n}\n\nconst DEFAULT_LIMITS: Required<Limits> = { turns: 8, retries: 2, maxTokens: 512, resultChars: 4000 };\nconst LIMIT_MIN: Required<Limits> = { turns: 1, retries: 0, maxTokens: 1, resultChars: 1 };\n\n// aerix-core's generate_turn wording.\nconst CUT_NOTE = \"Your last turn hit the token limit before the JSON closed; answer again, shorter.\";\nconst badNote = (error: string) => `Your last turn was not valid: ${error}. Answer again as JSON.`;\n\nconst isObject = (v: unknown): v is Record<string, unknown> =>\n  typeof v === \"object\" && v !== null && !Array.isArray(v);\nconst message = (e: unknown) => (e instanceof Error ? e.message : String(e));\nconst msg = (role: ChatMessage[\"role\"], content: string): ChatMessage => Object.freeze({ role, content });\nconst refuse = (text: string) => new AerixError(\"options\", text);\n\nfunction checkLimits(limits: unknown): Required<Limits> {\n  if (limits === undefined) return { ...DEFAULT_LIMITS };\n  if (!isObject(limits)) throw refuse(\"limits must be an object\");\n  const out = { ...DEFAULT_LIMITS };\n  for (const [k, v] of Object.entries(limits)) {\n    if (!Object.hasOwn(DEFAULT_LIMITS, k)) throw refuse(`unknown limit ${k}`);\n    if (v === undefined) continue;\n    const min = LIMIT_MIN[k as keyof Limits];\n    if (typeof v !== \"number\" || !Number.isInteger(v) || v < min) {\n      throw refuse(`limits.${k} must be an integer of at least ${min}`);\n    }\n    out[k as keyof Limits] = v;\n  }\n  return out;\n}\n\nfunction checkTools(tools: unknown): readonly Tool[] {\n  if (tools === undefined) return [];\n  if (!Array.isArray(tools)) throw refuse(\"tools must be an array\");\n  const names = new Set<string>();\n  for (const t of tools) {\n    if (!isObject(t) || typeof t.name !== \"string\" || typeof t.run !== \"function\" || !isObject(t.schema)) {\n      throw refuse(\"each tool must be made with tool()\");\n    }\n    if (!isObject(t.input)) throw refuse(`tool ${t.name}: input must be a field map (an object)`);\n    if (names.has(t.name)) throw refuse(`two tools are named ${t.name}`);\n    names.add(t.name);\n  }\n  return Object.freeze([...(tools as Tool[])]);\n}\n\nfunction checkGeneration(generation: unknown): Record<string, unknown> {\n  if (generation === undefined) return {};\n  if (!isObject(generation)) throw refuse(\"generation must be an object\");\n  for (const k of [\"maxTokens\", \"constraint\", \"signal\"]) {\n    if (Object.hasOwn(generation, k)) {\n      throw refuse(`generation.${k} is set by the agent (use limits.maxTokens, constrain or run's signal)`);\n    }\n  }\n  return { ...generation };\n}\n\nconst HOOK_NAMES: readonly string[] = [\"beforeCall\", \"afterCall\", \"onFinal\"];\n\nfunction checkHooks(hooks: unknown): Hooks {\n  if (hooks === undefined) return {};\n  if (!isObject(hooks)) throw refuse(\"hooks must be an object\");\n  // An own key that looks like a hook name (`beforeCal`, `onDone`: the prefix, then a capital) is a typo, whatever its value; any\n  // other own key is the instance's state.\n  for (const k of Object.keys(hooks)) {\n    if (!HOOK_NAMES.includes(k) && /^(before|after|on)[A-Z]/.test(k)) {\n      throw refuse(`unknown hook ${k} (hooks are ${HOOK_NAMES.join(\", \")})`);\n    }\n  }\n  // Read by name, not by own keys, so a hook on a class instance's prototype is kept.\n  const out: Record<string, unknown> = {};\n  for (const k of HOOK_NAMES) {\n    const f: unknown = hooks[k];\n    if (f === undefined) continue;\n    if (typeof f !== \"function\") throw refuse(`hooks.${k} must be a function`);\n    out[k] = f.bind(hooks);\n  }\n  return out as Hooks;\n}\n\n/** `text` cut to `cap` characters, with the note naming how long it was. */\nfunction capResult(text: string, cap: number): string {\n  if (text.length <= cap) return text;\n  const chars = Array.from(text);\n  if (chars.length <= cap) return text;\n  return `${chars.slice(0, cap).join(\"\")}\\n[result cut to ${cap} of ${chars.length} characters]`;\n}\n\nconst resultText = (v: unknown): string =>\n  typeof v === \"string\" ? v : v === undefined || v === null ? \"\" : (JSON.stringify(v) ?? String(v));\n\nconst ABORTED = Symbol(\"aborted\");\n\n/** Settles with `fn`'s outcome, or with ABORTED as soon as `signal` aborts. */\nasync function untilAbort<T>(\n  fn: () => T | Promise<T>,\n  signal: AbortSignal,\n): Promise<{ value: T } | { thrown: unknown } | typeof ABORTED> {\n  let onAbort = () => {};\n  const aborted = new Promise<typeof ABORTED>((resolve) => {\n    onAbort = () => resolve(ABORTED);\n    if (signal.aborted) onAbort();\n    else signal.addEventListener(\"abort\", onAbort, { once: true });\n  });\n  const ran = Promise.resolve()\n    .then(fn)\n    .then(\n      (value) => ({ value }),\n      (e: unknown) => ({ thrown: e }),\n    );\n  try {\n    return await Promise.race([ran, aborted]);\n  } finally {\n    signal.removeEventListener(\"abort\", onAbort);\n  }\n}\n\n/** A hook's answer, or ABORTED if the signal aborts first; a throwing hook ends the run with `error`. */\nasync function hook(fn: (() => unknown) | undefined, signal: AbortSignal): Promise<unknown> {\n  if (fn === undefined) return undefined;\n  const out = await untilAbort(fn, signal);\n  if (out === ABORTED) return ABORTED;\n  if (\"thrown\" in out) throw out.thrown;\n  return out.value;\n}\n\n/** Runs Aerix's turn loop on a `Model`: one run at a time, over one conversation. */\nexport class Agent {\n  readonly #model: Model;\n  readonly #tools: readonly Tool[];\n  readonly #limits: Required<Limits>;\n  readonly #generation: Record<string, unknown>;\n  readonly #constraint: GenerationOptions[\"constraint\"];\n  readonly #hooks: Hooks;\n  readonly #system: ChatMessage;\n  #messages: ChatMessage[];\n  #nextId = { n: 1 };\n  #busy = false;\n\n  constructor(o: AgentOptions) {\n    if (!isObject(o)) throw refuse(\"options must be an object\");\n    if (!isObject(o.model) || typeof (o.model as Partial<Model>).chat !== \"function\") {\n      throw refuse(\"model must have a chat method (a caldrix.js Engine does)\");\n    }\n    if (o.instructions !== undefined && typeof o.instructions !== \"string\") {\n      throw refuse(\"instructions must be a string\");\n    }\n    if (o.constrain !== undefined && typeof o.constrain !== \"boolean\") throw refuse(\"constrain must be a boolean\");\n    this.#model = o.model;\n    this.#tools = checkTools(o.tools);\n    this.#limits = checkLimits(o.limits);\n    this.#generation = checkGeneration(o.generation);\n    this.#hooks = checkHooks(o.hooks);\n    this.#constraint = o.constrain === false ? undefined : { json: turnSchema(this.#tools) };\n    this.#system = msg(\"system\", systemText(o.instructions ?? \"\", this.#tools));\n    this.#messages = [this.#system];\n  }\n\n  /** The conversation so far: the system message, then every prompt, turn and result. */\n  get messages(): readonly ChatMessage[] {\n    return Object.freeze([...this.#messages]);\n  }\n\n  /** Forgets the conversation (and restarts call ids at `c1`). */\n  reset(): void {\n    if (this.#busy) throw new AerixError(\"busy\", \"a run is going on this agent\");\n    this.#messages = [this.#system];\n    this.#nextId = { n: 1 };\n  }\n\n  /**\n   * Runs the loop on `prompt`, continuing the conversation. Ends with exactly one `final` or `end`\n   * event; it throws only `AerixError` kind `busy` (a run is already going) or `options`.\n   */\n  async *run(prompt: string, o: { signal?: AbortSignal } = {}): AsyncGenerator<AgentEvent, void, undefined> {\n    if (this.#busy) throw new AerixError(\"busy\", \"a run is already going on this agent\");\n    if (typeof prompt !== \"string\") throw refuse(\"prompt must be a string\");\n    const signal: unknown = o?.signal;\n    if (signal !== undefined && (!isObject(signal) || typeof signal.addEventListener !== \"function\")) {\n      throw refuse(\"signal must be an AbortSignal\");\n    }\n    this.#busy = true;\n    try {\n      yield* this.#loop(prompt, (signal as AbortSignal | undefined) ?? new AbortController().signal);\n    } finally {\n      this.#busy = false;\n    }\n  }\n\n  /** Runs to the end: resolves on a final, else rejects with `AerixError` kind `end`. */\n  async ask(prompt: string, o: { signal?: AbortSignal } = {}): Promise<{ text: string; events: AgentEvent[] }> {\n    const events: AgentEvent[] = [];\n    for await (const ev of this.run(prompt, o)) {\n      events.push(ev);\n      if (ev.type === \"final\") return { text: ev.text, events };\n      if (ev.type === \"end\") {\n        throw new AerixError(\"end\", ev.message ?? `the run ended without a final (${ev.reason})`, {\n          reason: ev.reason,\n          events,\n        });\n      }\n    }\n    throw new AerixError(\"end\", \"the run ended without a final\", { events });\n  }\n\n  async *#loop(prompt: string, signal: AbortSignal): AsyncGenerator<AgentEvent, void, undefined> {\n    const msgs = this.#messages;\n    const limits = this.#limits;\n    msgs.push(msg(\"user\", prompt));\n    let turnStart = msgs.length;\n    let done = false; // an ending event was yielded (or is about to be)\n    const end = (reason: EndReason, text?: string): AgentEvent => {\n      done = true;\n      msgs.length = turnStart; // a turn that did not complete is not kept\n      return text === undefined ? { type: \"end\", reason } : { type: \"end\", reason, message: text };\n    };\n    const spent = () => end(\"turns\", `the turn budget (${limits.turns}) is spent`);\n    let turn = 0;\n    try {\n      for (;;) {\n        // One turn: a generation, plus up to `retries` more after a bad or cut one.\n        turnStart = msgs.length;\n        let attempt = 0;\n        let text = \"\";\n        let parsed: ReturnType<typeof parseTurn>;\n        for (;;) {\n          if (signal.aborted) return yield end(\"abort\");\n          if (turn >= limits.turns) return yield spent();\n          turn++;\n          const opts: GenerateOptions = {\n            ...this.#generation,\n            maxTokens: limits.maxTokens,\n            ...(this.#constraint && { constraint: this.#constraint }),\n            signal,\n          };\n          text = \"\";\n          let finish: string | undefined;\n          for await (const d of this.#model.chat([...msgs], opts)) {\n            if (typeof d.text === \"string\" && d.text !== \"\") {\n              text += d.text;\n              yield { type: \"text\", text: d.text };\n            }\n            if (d.done) {\n              finish = d.finishReason;\n              if (d.usage) {\n                const { promptTokens, completionTokens } = d.usage;\n                yield { type: \"usage\", promptTokens, completionTokens };\n              }\n              break;\n            }\n          }\n          if (signal.aborted || finish === \"abort\") return yield end(\"abort\");\n          parsed = parseTurn(text, this.#tools, this.#nextId);\n          if (parsed.ok) break;\n          // Both spent on the same generation: the turn budget ran out first.\n          if (turn >= limits.turns) return yield spent();\n          if (attempt >= limits.retries) {\n            return yield end(\"retries\", `no valid turn after ${limits.retries} retries: ${parsed.error}`);\n          }\n          attempt++;\n          if (finish === \"length\") {\n            // The partial turn leaves the conversation; the model is asked for a shorter one.\n            yield { type: \"retry\", turn, reason: \"the turn hit the token limit before the JSON closed\" };\n            msgs.push(msg(\"user\", CUT_NOTE));\n          } else {\n            yield { type: \"retry\", turn, reason: parsed.error };\n            msgs.push(msg(\"assistant\", text), msg(\"user\", badNote(parsed.error)));\n          }\n        }\n        // A good turn: the bad answers and the notes leave the conversation.\n        msgs.length = turnStart;\n        msgs.push(msg(\"assistant\", text));\n        const t = parsed.turn;\n\n        if (t.kind === \"final\") {\n          const onFinal = this.#hooks.onFinal;\n          const next = await hook(onFinal && (() => onFinal(t.text)), signal);\n          if (next === ABORTED) return yield end(\"abort\");\n          if (isObject(next) && typeof next.continue === \"string\") {\n            msgs.push(msg(\"user\", next.continue));\n            continue;\n          }\n          done = true;\n          return yield { type: \"final\", text: t.text, ...(t.thought !== undefined && { thought: t.thought }) };\n        }\n\n        yield {\n          type: \"turn\",\n          turn,\n          ...(t.thought !== undefined && { thought: t.thought }),\n          calls: t.calls.map((c) => ({ ...c, input: { ...c.input } })),\n        };\n        // Calls run in order, one at a time; at most MAX_CALLS per turn (parseTurn).\n        for (const c of t.calls) {\n          if (signal.aborted) return yield end(\"abort\");\n          if ((yield* this.#call(c, signal)) === ABORTED) return yield end(\"abort\");\n        }\n      }\n    } catch (e) {\n      // An engine failure or a throwing hook ends the run; it is never thrown from the iterator.\n      yield signal.aborted ? end(\"abort\") : end(\"error\", message(e));\n    } finally {\n      // The caller left before an ending event: the unfinished turn is not kept.\n      if (!done) msgs.length = turnStart;\n    }\n  }\n\n  /** One call: the hooks, the input check and the tool, then its result appended to the conversation. */\n  async *#call(c: Call, signal: AbortSignal): AsyncGenerator<AgentEvent, typeof ABORTED | undefined, undefined> {\n    const t = this.#tools.find((x) => x.name === c.tool)!; // parseTurn admits known tools only\n    let input = c.input;\n    const { beforeCall, afterCall } = this.#hooks;\n    const before = await hook(beforeCall && (() => beforeCall({ ...c, input: { ...input } })), signal);\n    if (before === ABORTED) return ABORTED;\n    let text: string;\n    let error = true;\n    if (isObject(before) && typeof before.deny === \"string\") {\n      yield { type: \"call\", id: c.id, tool: c.tool, input: { ...input } };\n      text = `refused: ${before.deny}`;\n    } else {\n      if (isObject(before) && isObject(before.input)) input = { ...before.input };\n      yield { type: \"call\", id: c.id, tool: c.tool, input: { ...input } };\n      const bad = checkInput(t, input);\n      if (bad !== null) {\n        text = `error: ${bad}`;\n      } else {\n        const cx = { signal, callId: c.id };\n        const out = await untilAbort(async () => resultText(await t.run(input, cx)), signal);\n        if (out === ABORTED || signal.aborted) return ABORTED;\n        if (\"value\" in out) {\n          text = out.value;\n          error = false;\n        } else {\n          text = `error: ${message(out.thrown)}`;\n        }\n        const ran = text;\n        const after = await hook(afterCall && (() => afterCall({ ...c, input: { ...input } }, ran)), signal);\n        if (after === ABORTED) return ABORTED;\n        if (isObject(after) && typeof after.result === \"string\") text = after.result;\n      }\n    }\n    text = capResult(text, this.#limits.resultChars);\n    this.#messages.push(msg(\"user\", `[${c.tool} ${c.id}]\\n${text}`));\n    yield { type: \"result\", id: c.id, tool: c.tool, text, error };\n    return undefined;\n  }\n}\n"],"mappings":"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","names":["message","isObject","isObject","bad"]}

package/package.json

@@ -1,6 +1,62 @@
 {
   "name": "@caldrix-ai/aerix",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "private": false,
+  "description": "Aerix's turn loop on a caldrix.js engine, in the browser.",
+  "license": "Apache-2.0",
+  "homepage": "https://caldrix.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/100xeng/caldrix.git",
+    "directory": "aerix-js"
+  },
+  "keywords": [
+    "llm",
+    "agent",
+    "tools",
+    "browser"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "peerDependencies": {
+    "@caldrix-ai/caldrix": "^0.3.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "0.18.5",
+    "@caldrix-ai/caldrix": "link:../caldrix-js",
+    "@eslint/js": "^9.39.5",
+    "@playwright/test": "1.63.0",
+    "@types/node": "^26.1.1",
+    "eslint": "^9.39.5",
+    "publint": "0.3.25",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.46.0",
+    "vitest": "^4.1.10"
+  },
+  "scripts": {
+    "build": "tsup",
+    "build:test": "tsup --config tsup.test.config.ts",
+    "lint": "eslint . && tsc --noEmit",
+    "test": "vitest run",
+    "test:e2e": "playwright test",
+    "pack:check": "publint && attw --pack . --ignore-rules cjs-resolves-to-esm"
+  }
 }