@tangleai/models 0.21.1 → 0.24.1

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @tangleai/models
 
+## 0.24.1
+
+No changes in this release.
+
+## 0.24.0
+
+No changes in this release.
+
+## 0.23.0
+
+No changes in this release.
+
+## 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.
+
 ## 0.21.1
 
 ### Patch Changes

package/README.md

@@ -2,7 +2,8 @@
 
 Injected model clients, provider adapters, embeddings, replay, routing and structured generation.
 
-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.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangleai/models",
-  "version": "0.21.1",
+  "version": "0.24.1",
   "description": "Injected model clients, provider adapters, embeddings, replay, routing and structured generation.",
   "license": "MIT",
   "type": "module",
@@ -69,8 +69,8 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@jarenjs/core": "0.84.3",
-    "@jarenjs/validate": "0.84.3"
+    "@jarenjs/core": "0.86.0",
+    "@jarenjs/validate": "0.86.0"
   },
   "private": false,
   "files": [

package/src/check.d.ts

@@ -1,3 +1,7 @@
+/** Model-facing validation feedback over the shared strict check contract. */
+/** Validation errors reported back per rejected write — enough to fix
+ * from, few enough to stay readable in a model's context. */
+export declare const MAX_INPUT_ERRORS = 8;
 /**
  * The one rejection shape every schema-guarded boundary in this package
  * answers with: `{ error, errors, inputSchema }`, never a throw. The
@@ -10,20 +14,15 @@
  * (the toolbox's `hint`), then `inputSchema` last, because the schema is
  * the biggest member and a reader scans the message first.
  *
- * @param {string} what - what was being validated (`add`, `memory`, …)
- * @param {{ errors: any[] }} outcome - a normalized {@link checkOutcome}
- * @param {any} inputSchema - the schema to re-read
- * @param {Record<string, any>} [extra] - boundary-specific members
- * @returns {{ error: string, errors: any[], inputSchema: any }}
+ * @param what - what was being validated (`add`, `memory`, …)
+ * @param outcome - a normalized {@link checkOutcome}
+ * @param inputSchema - the schema to re-read
+ * @param [extra] - boundary-specific members
  */
-export function invalidInput(what: string, outcome: {
+export declare function invalidInput(what: string, outcome: {
     errors: any[];
 }, inputSchema: any, extra?: Record<string, any>): {
     error: string;
     errors: any[];
     inputSchema: any;
 };
-/** Model-facing validation feedback over the shared strict check contract. */
-/** Validation errors reported back per rejected write — enough to fix
- * from, few enough to stay readable in a model's context. */
-export const MAX_INPUT_ERRORS: 8;

package/src/check.js

@@ -1,10 +1,7 @@
-//@ts-check
 /** Model-facing validation feedback over the shared strict check contract. */
-
 /** Validation errors reported back per rejected write — enough to fix
  * from, few enough to stay readable in a model's context. */
 export const MAX_INPUT_ERRORS = 8;
-
 /**
  * The one rejection shape every schema-guarded boundary in this package
  * answers with: `{ error, errors, inputSchema }`, never a throw. The
@@ -17,21 +14,20 @@ export const MAX_INPUT_ERRORS = 8;
  * (the toolbox's `hint`), then `inputSchema` last, because the schema is
  * the biggest member and a reader scans the message first.
  *
- * @param {string} what - what was being validated (`add`, `memory`, …)
- * @param {{ errors: any[] }} outcome - a normalized {@link checkOutcome}
- * @param {any} inputSchema - the schema to re-read
- * @param {Record<string, any>} [extra] - boundary-specific members
- * @returns {{ error: string, errors: any[], inputSchema: any }}
+ * @param what - what was being validated (`add`, `memory`, …)
+ * @param outcome - a normalized {@link checkOutcome}
+ * @param inputSchema - the schema to re-read
+ * @param [extra] - boundary-specific members
  */
 export function invalidInput(what, outcome, inputSchema, extra = {}) {
-  return {
-    error: `invalid input for ${what}`,
-    errors: outcome.errors.slice(0, MAX_INPUT_ERRORS).map((e) => ({
-      instancePath: e.instancePath ?? '',
-      keyword: e.keyword ?? '',
-      message: e.message ?? 'invalid',
-    })),
-    ...extra,
-    inputSchema,
-  };
+    return {
+        error: `invalid input for ${what}`,
+        errors: outcome.errors.slice(0, MAX_INPUT_ERRORS).map((e) => ({
+            instancePath: e.instancePath ?? '',
+            keyword: e.keyword ?? '',
+            message: e.message ?? 'invalid',
+        })),
+        ...extra,
+        inputSchema,
+    };
 }

package/src/client.d.ts

@@ -1,63 +1,35 @@
+/**
+ * The chat client: one `complete()` call against any OpenAI-compatible
+ * `/chat/completions` endpoint, streaming by default. The host injects
+ * `fetch` exactly like every other jarenjs boundary injects its
+ * environment, so the client runs identically in the browser, in Node
+ * and in tests against a scripted stub.
+ *
+ * The reply is normalized to `{ message: { role, content, toolCalls },
+ * finishReason, usage, model }` whether the server streamed deltas or
+ * answered in one JSON document.
+ */
 /**
  * The reasoning text one streamed chunk carries: the OpenRouter/`o`-
  * family `delta.reasoning` string, or the `reasoning_details` text
  * entries some providers emit instead.
- * @param {any} delta
- * @returns {string}
  */
-export function reasoningOf(delta: any): string;
+export declare function reasoningOf(delta: any): string;
 /**
  * Accumulates OpenAI streaming chunks (`choices[0].delta`) into one
  * normalized assistant message. Tool-call fragments merge by `index`;
  * argument strings concatenate across chunks; reasoning deltas
  * accumulate into `message.reasoning` (absent when the model emitted
  * none) so a reasoning-only turn is distinguishable from an empty one.
- * @returns {{ push: (chunk: any) => string, result: () => any }}
+ * @returns
  *   `push` returns the text delta this chunk contributed (may be '').
  */
-export function createStreamAccumulator(): {
+export declare function createStreamAccumulator(): {
     push: (chunk: any) => string;
     result: () => any;
 };
 /**
- * @typedef {Object} ChatRequest
- * @property {any[]} messages - OpenAI wire-shape messages
- * @property {any[]} [tools] - OpenAI function-tool definitions
- * @property {any} [toolChoice] - `tool_choice` passthrough
- * @property {string} [model] - overrides the client's configured model
- * @property {number} [temperature]
- * @property {number} [maxTokens] - token ceiling for this reply, sent under
- *   the client's `maxTokensField`. Overrides the client default; when
- *   both are unset, the provider chooses the limit. With
- *   `max_completion_tokens`, reasoning tokens share this budget with
- *   visible output tokens.
- * @property {boolean} [stream] - default true
- * @property {{ name?: string, schema?: any, strict?: boolean, type?: 'json' }} [responseFormat]
- *   - structured output: `{ name, schema, strict? }` emits the OpenAI
- *   `response_format: { type: "json_schema", … }` wire shape (strict
- *   defaults to true); `{ type: 'json' }` emits `json_object` mode
- * @property {{ effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high',
- *   enabled?: boolean, exclude?: boolean, max_tokens?: number }} [reasoning]
- *   - the provider-normalized thinking control, forwarded verbatim.
- *   `{ effort: 'none' }` (or `{ enabled: false }`) turns a hybrid
- *   thinking model OFF: it answers directly, which on a short task is
- *   dramatically cheaper and faster. `{ exclude: true }` only HIDES the
- *   thinking — the model still thinks and you still pay for it.
- *   Overrides the client-level default.
- * @property {AbortSignal} [signal]
- * @property {(text: string) => void} [onDelta] - streamed text callback
- * @property {(text: string) => void} [onReasoning] - streamed reasoning
- *   callback (reasoning models emit thinking before/instead of content)
- */
-/**
- * @param {{ provider?: string, baseUrl?: string, apiKey?: string,
- *   model?: string, headers?: Record<string, string>,
- *   fetch?: typeof fetch, maxTokens?: number,
- *   maxTokensField?: 'max_tokens' | 'max_completion_tokens',
- *   reasoning?: { effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high',
- *     enabled?: boolean, exclude?: boolean, max_tokens?: number },
- *   retry?: import('./retry.js').RetryOptions,
- *   cache?: import('./replay.js').ReplayCache }} [options]
+ * @param [options]
  *   - `maxTokensField` selects the wire field for client and request
  *     `maxTokens` budgets (default `'max_tokens'`). Select
  *     `'max_completion_tokens'` for OpenAI Chat Completions, including
@@ -86,11 +58,8 @@ export function createStreamAccumulator(): {
  *     value it asked for rides the final error as `retryAfterMs` for
  *     the caller to honour. `random` and `sleep` exist for deterministic
  *     tests.
- * @returns {{ endpoint: { provider: string, base: string, url: string,
- *   headers: Record<string, string>, model: string },
- *   complete: (request: ChatRequest) => Promise<any> }}
  */
-export function createChatClient(options?: {
+export declare function createChatClient(options?: {
     provider?: string;
     baseUrl?: string;
     apiKey?: string;
@@ -98,15 +67,15 @@ export function createChatClient(options?: {
     headers?: Record<string, string>;
     fetch?: typeof fetch;
     maxTokens?: number;
-    maxTokensField?: "max_tokens" | "max_completion_tokens";
+    maxTokensField?: 'max_tokens' | 'max_completion_tokens';
     reasoning?: {
-        effort?: "none" | "minimal" | "low" | "medium" | "high";
+        effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high';
         enabled?: boolean;
         exclude?: boolean;
         max_tokens?: number;
     };
-    retry?: import("./retry.js").RetryOptions;
-    cache?: import("./replay.js").ReplayCache;
+    retry?: import('./retry.ts').RetryOptions;
+    cache?: import('./replay.ts').ReplayCache;
 }): {
     endpoint: {
         provider: string;
@@ -118,68 +87,56 @@ export function createChatClient(options?: {
     complete: (request: ChatRequest) => Promise<any>;
 };
 export type ChatRequest = {
-    /**
-     * - OpenAI wire-shape messages
-     */
-    messages: any[];
-    /**
-     * - OpenAI function-tool definitions
-     */
-    tools?: any[];
-    /**
-     * - `tool_choice` passthrough
-     */
-    toolChoice?: any;
-    /**
-     * - overrides the client's configured model
-     */
+    messages: any[]; /**
+   * - OpenAI function-tool definitions
+   */
+    tools?: any[]; /**
+   * - `tool_choice` passthrough
+   */
+    toolChoice?: any; /**
+   * - overrides the client's configured model
+   */
     model?: string;
-    temperature?: number;
-    /**
-     * - token ceiling for this reply, sent under
-     * the client's `maxTokensField`. Overrides the client default; when
-     * both are unset, the provider chooses the limit. With
-     * `max_completion_tokens`, reasoning tokens share this budget with
-     * visible output tokens.
-     */
-    maxTokens?: number;
-    /**
-     * - default true
-     */
-    stream?: boolean;
-    /**
-     * - structured output: `{ name, schema, strict? }` emits the OpenAI
-     * `response_format: { type: "json_schema", … }` wire shape (strict
-     * defaults to true); `{ type: 'json' }` emits `json_object` mode
-     */
+    temperature?: number; /**
+   * - token ceiling for this reply, sent under
+   * the client's `maxTokensField`. Overrides the client default; when
+   * both are unset, the provider chooses the limit. With
+   * `max_completion_tokens`, reasoning tokens share this budget with
+   * visible output tokens.
+   */
+    maxTokens?: number; /**
+   * - default true
+   */
+    stream?: boolean; /**
+   * - structured output: `{ name, schema, strict? }` emits the OpenAI
+   * `response_format: { type: "json_schema", … }` wire shape (strict
+   * defaults to true); `{ type: 'json' }` emits `json_object` mode
+   */
     responseFormat?: {
         name?: string;
         schema?: any;
         strict?: boolean;
         type?: "json";
-    };
-    /**
-     * - the provider-normalized thinking control, forwarded verbatim.
-     * `{ effort: 'none' }` (or `{ enabled: false }`) turns a hybrid
-     * thinking model OFF: it answers directly, which on a short task is
-     * dramatically cheaper and faster. `{ exclude: true }` only HIDES the
-     * thinking — the model still thinks and you still pay for it.
-     * Overrides the client-level default.
-     */
+    }; /**
+   * - the provider-normalized thinking control, forwarded verbatim.
+   * `{ effort: 'none' }` (or `{ enabled: false }`) turns a hybrid
+   * thinking model OFF: it answers directly, which on a short task is
+   * dramatically cheaper and faster. `{ exclude: true }` only HIDES the
+   * thinking — the model still thinks and you still pay for it.
+   * Overrides the client-level default.
+   */
     reasoning?: {
         effort?: "none" | "minimal" | "low" | "medium" | "high";
         enabled?: boolean;
         exclude?: boolean;
         max_tokens?: number;
     };
-    signal?: AbortSignal;
-    /**
-     * - streamed text callback
-     */
-    onDelta?: (text: string) => void;
-    /**
-     * - streamed reasoning
-     * callback (reasoning models emit thinking before/instead of content)
-     */
+    signal?: AbortSignal; /**
+   * - streamed text callback
+   */
+    onDelta?: (text: string) => void; /**
+   * - streamed reasoning
+   * callback (reasoning models emit thinking before/instead of content)
+   */
     onReasoning?: (text: string) => void;
 };