@noetic-tools/core 0.0.1

package/dist/until/predicates.js

@@ -0,0 +1,126 @@
+import { cosineSimilarity } from '../conditions/cosine-similarity';
+import { never } from './never';
+const CONVERGE_CACHE_KEY = 'converge:previousVector';
+/**
+ * Namespace of built-in loop termination predicates.
+ *
+ * @public
+ */
+export const until = {
+    /** Stops the loop after `n` steps. @public */
+    maxSteps(n) {
+        return (snap) => ({
+            stop: snap.stepCount >= n,
+            reason: snap.stepCount >= n ? `Reached max steps (${n})` : undefined,
+        });
+    },
+    /** Stops the loop when accumulated cost reaches `usd`. @public */
+    maxCost(usd) {
+        return (snap) => ({
+            stop: snap.cost >= usd,
+            reason: snap.cost >= usd ? `Reached max cost ($${usd})` : undefined,
+        });
+    },
+    /** Stops the loop when elapsed time reaches `ms` milliseconds. @public */
+    maxDuration(ms) {
+        return (snap) => ({
+            stop: snap.elapsed >= ms,
+            reason: snap.elapsed >= ms ? `Reached max duration (${ms}ms)` : undefined,
+        });
+    },
+    /** Stops the loop when the last model response contains no tool calls. @public */
+    noToolCalls() {
+        return (snap) => {
+            if (snap.stepCount < 1) {
+                return {
+                    stop: false,
+                };
+            }
+            const meta = snap.lastStepMeta;
+            const hasToolCalls = meta?.toolCalls && meta.toolCalls.length > 0;
+            return {
+                stop: !hasToolCalls,
+                reason: !hasToolCalls ? 'No tool calls in last response' : undefined,
+            };
+        };
+    },
+    /** Never stops the loop — pairs with operators like `every` that rely on cancellation. @public */
+    never,
+    /** Stops the loop when the verify function returns `{ pass: true }`. @public */
+    verified(fn) {
+        return async (snap) => {
+            const result = await fn(snap.lastOutput);
+            return {
+                stop: result.pass,
+                reason: result.pass ? 'Verification passed' : undefined,
+                feedback: result.feedback,
+            };
+        };
+    },
+    /** Stops the loop when consecutive outputs are similar (exact equality or embedding cosine similarity). @public */
+    converged(opts) {
+        const threshold = opts.threshold ?? 1;
+        const { embed } = opts;
+        if (!embed || threshold >= 1) {
+            // Exact string equality (original behavior)
+            let previousOutput = null;
+            return (snap) => {
+                const currentText = snap.lastText;
+                if (previousOutput === null) {
+                    previousOutput = currentText;
+                    return {
+                        stop: false,
+                    };
+                }
+                const similar = currentText === previousOutput;
+                previousOutput = currentText;
+                return {
+                    stop: similar,
+                    reason: similar ? 'Output converged' : undefined,
+                };
+            };
+        }
+        // Embedding-based similarity — embed is narrowed to EmbedFn here
+        let previousVector = null;
+        const persistVector = async (vector) => {
+            if (opts.cache) {
+                await opts.cache.set(CONVERGE_CACHE_KEY, vector);
+            }
+            previousVector = vector;
+        };
+        return async (snap) => {
+            const currentText = snap.lastText;
+            const [currentVector] = await embed([
+                currentText,
+            ]);
+            // Try to load previous vector from cache if we don't have one in closure
+            if (!previousVector && opts.cache) {
+                previousVector = await opts.cache.get(CONVERGE_CACHE_KEY);
+            }
+            if (!previousVector) {
+                await persistVector(currentVector);
+                return {
+                    stop: false,
+                };
+            }
+            const similarity = cosineSimilarity(currentVector, previousVector);
+            await persistVector(currentVector);
+            const converged = similarity >= threshold;
+            return {
+                stop: converged,
+                reason: converged ? `Output converged (similarity: ${similarity.toFixed(3)})` : undefined,
+            };
+        };
+    },
+    /** Stops the loop when the last output text contains the given marker string. @public */
+    outputContains(marker) {
+        return (snap) => ({
+            stop: snap.lastText.includes(marker),
+            reason: snap.lastText.includes(marker) ? `Output contains marker: ${marker}` : undefined,
+        });
+    },
+    /** Wraps an arbitrary `Until` function as a named predicate. @public */
+    custom(fn) {
+        return fn;
+    },
+};

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@noetic-tools/core",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "Step primitives, interpreter, runtime, and memory layer contract for Noetic agents.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mattapperson/noetic.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/mattapperson/noetic#readme",
+  "bugs": {
+    "url": "https://github.com/mattapperson/noetic/issues"
+  },
+  "keywords": [
+    "noetic",
+    "agents",
+    "llm",
+    "ai",
+    "openrouter",
+    "agent-framework"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./portable": {
+      "types": "./dist/portable.d.ts",
+      "default": "./dist/portable.js"
+    },
+    "./unstable": {
+      "types": "./dist/unstable.d.ts",
+      "default": "./dist/unstable.js"
+    },
+    "./internal/test": {
+      "types": "./dist/internal-test.d.ts",
+      "default": "./dist/internal-test.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@openrouter/agent": "^0.6.0",
+    "bun-types": "latest"
+  },
+  "peerDependencies": {
+    "@openrouter/agent": "^0.6.0",
+    "zod": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@openrouter/agent": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@openrouter/agent": "^0.6.0",
+    "zod": "^4.0.0"
+  },
+  "scripts": {
+    "build": "bunx tsc -p tsconfig.build.json",
+    "prepublishOnly": "rm -rf dist && bun run build",
+    "test": "bun test",
+    "test:coverage": "bun test --coverage --coverage-reporter=text --coverage-reporter=json",
+    "test:ci": "bun test --coverage --coverage-reporter=json",
+    "typecheck": "bunx tsc --noEmit",
+    "lint": "bunx biome check .",
+    "lint:fix": "bunx biome check --fix .",
+    "format": "bunx biome format --write .",
+    "format:check": "bunx biome format ."
+  }
+}