@tangleai/agents 0.21.1 → 0.24.1

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # @tangleai/agents
 
+## 0.24.1
+
+### Patch Changes
+
+- @tangleai/context@0.24.1
+  - @tangleai/models@0.24.1
+
+## 0.24.0
+
+### Patch Changes
+
+- @tangleai/context@0.24.0
+  - @tangleai/models@0.24.0
+
+## 0.23.0
+
+### Patch Changes
+
+- @tangleai/context@0.23.0
+  - @tangleai/models@0.23.0
+
+## 0.22.0
+
+### Patch Changes
+
+- Convert the migrated source, tests, benchmarks and hosts to strict TypeScript,
+  with JavaScript and declarations emitted through one release build. Move the
+  program pen from `@tangleai/jaren/program` and the Jaren integration barrel to
+  `@tangleai/linq/program`, preserving its JSON format and phantom binding types.
+  The new `@tangleai/linq` root exposes the program namespace and shared build error.
+
+  Match the embedder declarations to unknown widths before the first response,
+  retain precise ledger result variants, and enforce the refinement-pressure
+  instrument's stated 60-second deadline through the chat client's abort signal.
+- Updated dependencies
+  - @tangleai/models@0.22.0
+  - @tangleai/context@0.22.0
+
 ## 0.21.1
 
 ### Patch Changes

package/README.md

@@ -2,7 +2,8 @@
 
 Validated tools, bounded agents, action programs, recursive execution and guarded refinement.
 
-This package keeps its JS/JSDoc implementation and deterministic tests. Inject
+The implementation and deterministic tests use strict TypeScript. Published
+packages contain ESM JavaScript and declarations emitted from that source. Inject
 fetch, storage and compiler services at the existing seams. The public source
 exports and emitted npm JavaScript share one implementation.
 
@@ -164,7 +165,7 @@ Back it with `@jarenjs/db` over OPFS, with one `localStorage` slot, with a file,
 server — or with nothing. The package gains no dependency either way, which is the whole
 posture: storage stays injected and it degrades to in-memory and
 schema-only. This site's assistant backs it with a single JSON slot
-([`ledgerStore.js`](https://github.com/jklarenbeek/jarenjs/blob/main/packages/website/src/lib/ledgerStore.js)), which is all a browser session
+([`storage/slot.ts`](../context/src/storage/slot.ts)), which is all a browser session
 needs. The ledger serializes its own writes. An adapter with `mutate` also
 serializes other writers at storage; `ledger.concurrency` reports `atomic` or
 `single-writer`. Four-method adapters require host coordination between writers.
@@ -247,7 +248,7 @@ const { memories, scores, skipped } = await ledger.recall({
   collection is the query language's own k-nearest composition (QUERY-FORMAT §8.15) — and
   over a `derive: 'vector'` column the store plans it as a cut the engine finishes, with
   `explain()` naming the mode (its ARCHITECTURE, "The k-nearest plan").
-- **Measured, whichever way it fell.** `benchmark/retrieval.js` scores the ranked path beside the
+- **Measured, whichever way it fell.** `benchmark/retrieval.ts` scores the ranked path beside the
   default over the same seeded corpus, through the deterministic reference embedder
   (§Embeddings — lexical, so a mechanism score, not a model-quality claim): <!--fact:retrieval.ranked-->5.0% of questions at 10,000 memories through the hash-trigram-64 reference embedder (33.8% at 1,000), ahead of tag match and recency's 1.3%<!--/fact-->.
   A real model's number is the host's to measure through the same instrument's `--live` tier.
@@ -487,7 +488,7 @@ the model fetches a round back when it needs one — a normal tool call that sho
   a round while claiming an address for it, which is the failure this exists to remove.
 
 The contract, asserted over every budget the benchmark sweeps in both payload shapes
-(`test/agents/compaction-recovery.test.js`): **every fact the full transcript held is either
+(`test/agents/compaction-recovery.test.ts`): **every fact the full transcript held is either
 still in the request verbatim or reachable through an address the request names** — <!--fact:horizon.ledgerRecovered-->40 of 40<!--/fact--> record values at the same budget, where the same runs without a ledger keep <!--fact:horizon.synopsisBand-->1 to 28<!--/fact--> of them. What that
 costs is a few characters of verbatim retention at the tightest budgets, published beside
 the win.
@@ -529,7 +530,7 @@ Without a `ledger`, all of this is inert and compaction behaves exactly as it al
 
 ## The action language — a program the model writes and the compiler checks
 
-For typed fixture and host authoring, the [AI program pen](../jaren/docs/PROGRAM-PEN.md)
+For typed fixture and host authoring, the [AI program pen](../linq/docs/PROGRAM-PEN.md)
 emits this same document and imports no AI runtime.
 
 The environment lets a model *address* a corpus. A program lets it *work* one: a small
@@ -574,7 +575,7 @@ Three properties, each asserted rather than intended:
   compile keeps the **query engine's own** code (`JQ0003`, …) with its pointer rebased onto
   the step it came from.
 - **No step can carry content.** Every member of every step is an operation name, a binding,
-  a slot reference, a bounded instruction or a query document — `test/agents/program.test.js`
+  a slot reference, a bounded instruction or a query document — `test/agents/program.test.ts`
   walks the grammar and fails if a string member is ever declared without a cap. So the
   program is the same size for a 10 kB corpus and a 10 MB one, which is what keeps the root
   request flat while a program runs.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangleai/agents",
-  "version": "0.21.1",
+  "version": "0.24.1",
   "description": "Validated tools, bounded agents, action programs, recursive execution and guarded refinement.",
   "license": "MIT",
   "type": "module",
@@ -59,11 +59,11 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@jarenjs/core": "0.84.3",
-    "@jarenjs/validate": "0.84.3",
-    "@tangleai/models": "^0.21.1",
-    "@tangleai/context": "^0.21.1",
-    "@jarenjs/contract": "0.84.3"
+    "@jarenjs/core": "0.86.0",
+    "@jarenjs/validate": "0.86.0",
+    "@tangleai/models": "^0.24.1",
+    "@tangleai/context": "^0.24.1",
+    "@jarenjs/contract": "0.86.0"
   },
   "private": false,
   "files": [

package/src/agent.d.ts

@@ -1,23 +1,32 @@
 /**
- * @typedef {Object} AgentHooks
- * @property {(text: string) => void} [onDelta] - streamed reply text
- * @property {(text: string) => void} [onReasoning] - streamed thinking
- * @property {(call: { name: string, arguments: string }) => void} [onToolCall]
- * @property {(step: { name: string, result: any }) => void} [onToolResult]
- * @property {AbortSignal} [signal]
+ * The agent loop: a bounded, deterministic tool-call round-trip over a
+ * chat client and a toolbox. The model proposes tool calls; the loop
+ * executes them through the schema-guarded toolbox, appends the
+ * results, and asks again — up to `maxToolRounds` times, then it stops
+ * and says so instead of spinning. Weak local models are first-class
+ * citizens here: malformed tool arguments and failing tools become
+ * readable `{ error }` results the model can correct, never crashes.
+ *
+ * `send` never mutates the history it is given; it returns the full
+ * new transcript (wire-shape messages) so the host can persist it and
+ * send it back next turn.
+ *
+ * Given a `ledger`, compaction stops destroying: every round that
+ * leaves the request is written to an addressable slot first, the
+ * synopsis carries the addresses, and a `recall` tool fetches one back.
+ * Without a ledger the old path runs unchanged, synchronously, byte for
+ * byte — the new behaviour is opt-in and named.
+ *
+ * A ledger also gives the loop an OBJECTIVE and a BUDGET. The active
+ * goal and its progress are composed into the system prompt of every
+ * request — unconditionally, because it is the thing being worked on —
+ * while memories and skills are retrieved only when asked for. The
+ * composition happens in the REQUEST and never in the transcript: the
+ * history the host persists stays the immutable base prompt plus the
+ * conversation, so a resumed session composes today's goal rather than
+ * accumulating yesterday's.
  */
 /**
- * @param {{ client: { complete: (request: any) => Promise<any> },
- *   toolbox?: { toFunctionTools: () => any[], execute: (name: string, args: any) => any } | null,
- *   system?: string, maxToolRounds?: number, maxToolResultChars?: number,
- *   historyBudget?: number, ledger?: any,
- *   budget?: { turns?: number, tokens?: number, ms?: number,
- *     spent?: { turns?: number, tokens?: number, ms?: number } },
- *   retrieval?: { memories?: { tags?: string[], where?: any, limit?: number },
- *     skills?: { tags?: string[], where?: any, limit?: number } },
- *   now?: () => number,
- *   environment?: any, transcript?: { slot?: string, window?: number },
- *   compaction?: (droppedRounds: any[][], addresses?: any[]) => string }} options
  *   - `historyBudget` caps the request history in CHARACTERS (tokens
  *   are provider-private; characters are deterministic). When a
  *   request would exceed it, the middle of the conversation is
@@ -63,13 +72,8 @@
  *   no budget to exceed when the history is addressed instead of resent.
  *   Both together is legal and redundant; neither changes the other's
  *   behaviour.
- * @returns {{ send: (history: any[], hooks?: AgentHooks) => Promise<{
- *   message: any, messages: any[], steps: any[], stopReason: string }>,
- *   resume: (history?: any[], hooks?: AgentHooks) => Promise<{
- *   message: any, messages: any[], steps: any[], stopReason: string }>,
- *   spend: () => { turns: number, tokens: number, ms: number } }}
  */
-export function createAgent(options: {
+export declare function createAgent(options: {
     client: {
         complete: (request: any) => Promise<any>;
     };
@@ -135,18 +139,12 @@ export function createAgent(options: {
  * message, then its content. Line-oriented on purpose — `grep` reports
  * the line that matched, so a tool result written as one JSON line comes
  * back as one legible hit with its address beside it.
- * @param {any[]} messages
- * @returns {string}
  */
-export function transcriptText(messages: any[]): string;
+export declare function transcriptText(messages: any[]): string;
 export type AgentHooks = {
-    /**
-     * - streamed reply text
-     */
-    onDelta?: (text: string) => void;
-    /**
-     * - streamed thinking
-     */
+    onDelta?: (text: string) => void; /**
+   * - streamed thinking
+   */
     onReasoning?: (text: string) => void;
     onToolCall?: (call: {
         name: string;