@zenera/neo 1.1.0

package/dist/types.js

@@ -0,0 +1,134 @@
+const MEDIA_KEYS = ['image', 'audio', 'video', 'file'];
+export function text(value) {
+    return { type: 'text', text: value };
+}
+export function media(kind, url, mimeType) {
+    return { type: kind, url, mimeType };
+}
+/** Normalizes any accepted input shape into a flat `ContentPart[]`. */
+export function toContent(input) {
+    if (typeof input === 'string') {
+        return [text(input)];
+    }
+    return input.map((part) => {
+        if (typeof part === 'string') {
+            return text(part);
+        }
+        // `'type' in part` is a TS narrowing guard: it splits the union into the
+        // canonical `ContentPart` branch and the `{ image: url }` shorthands.
+        if ('type' in part) {
+            return part;
+        }
+        // Shorthand: exactly one of image/audio/video/file carries the url.
+        for (const kind of MEDIA_KEYS) {
+            const url = part[kind];
+            if (typeof url === 'string') {
+                return media(kind, url, part.mimeType);
+            }
+        }
+        throw new TypeError(`unsupported input part: ${JSON.stringify(part)}`);
+    });
+}
+export function contentToText(content) {
+    return content.map((p) => (p.type === 'text' ? p.text : `[${p.type}: ${p.url}]`)).join('\n');
+}
+export function zeroUsage() {
+    return { inputTokens: 0, cachedInputTokens: 0, outputTokens: 0, reasoningTokens: 0 };
+}
+export function addUsage(a, b) {
+    return {
+        inputTokens: a.inputTokens + b.inputTokens,
+        cachedInputTokens: a.cachedInputTokens + b.cachedInputTokens,
+        outputTokens: a.outputTokens + b.outputTokens,
+        reasoningTokens: a.reasoningTokens + b.reasoningTokens,
+    };
+}
+const TOOL_RETURN = Symbol('agent.toolReturn');
+export function withEffects(output, ...effects) {
+    return { [TOOL_RETURN]: true, output, effects };
+}
+export function isToolReturn(v) {
+    return v !== null && typeof v === 'object' && TOOL_RETURN in v;
+}
+/**
+ * Identity helper. Its only job is inference: written inline, `execute`'s
+ * `args` would be `unknown`; going through `tool<{city: string}>()` types it.
+ */
+export function tool(def) {
+    return def;
+}
+/**
+ * Resolves selectors against the tools a host provided, in the order written
+ * and without duplicates. A selector is a tool name, `<group>:*` for every tool
+ * in a group, or `*` for everything; any of them prefixed with `-` removes
+ * what it matches from the selection so far.
+ */
+export function selectTools(available, selectors, opts) {
+    const chosen = new Map();
+    for (const raw of selectors) {
+        const drop = raw.startsWith('-');
+        const selector = (drop ? raw.slice(1) : raw).trim();
+        if (!selector) {
+            throw new Error(`${opts.where}: empty tool selector`);
+        }
+        for (const t of matchTools(available, selector, opts)) {
+            if (drop) {
+                chosen.delete(t.name);
+            }
+            else {
+                chosen.set(t.name, t);
+            }
+        }
+    }
+    return [...chosen.values()];
+}
+function matchTools(available, selector, opts) {
+    if (selector === '*') {
+        return available;
+    }
+    if (selector.endsWith(':*')) {
+        const group = selector.slice(0, -2);
+        const hits = available.filter((t) => t.group === group);
+        if (hits.length === 0) {
+            const groups = [...new Set(available.map((t) => t.group).filter(Boolean))];
+            throw new Error(`${opts.where}: no tools in group "${group}" ` +
+                `(known groups: ${groups.join(', ') || 'none'})`);
+        }
+        return hits;
+    }
+    const exact = available.find((t) => t.name === selector);
+    if (exact) {
+        return [exact];
+    }
+    const known = available.map((t) => t.name).join(', ') || 'none';
+    throw new Error(`${opts.where}: unknown tool "${selector}" ` +
+        (opts.hint ? `(${opts.hint}; known: ${known})` : `(known: ${known})`));
+}
+// Built-in tool names. Hand-offs, memory, skills and forks are all ordinary
+// tools, so the model drives everything with one mechanism; the kernel
+// recognises them by these names alone.
+export const HANDOFF_PREFIX = 'transfer_to_';
+export const FORK_TOOL = 'fork';
+export const FINAL_OUTPUT_TOOL = 'final_output';
+export const MEMORY_SEARCH_TOOL = 'memory_search';
+export const MEMORY_WRITE_TOOL = 'memory_write';
+export const MEMORY_UPDATE_TOOL = 'memory_update';
+export const MEMORY_DELETE_TOOL = 'memory_delete';
+export const SKILL_SEARCH_TOOL = 'skill_search';
+export const SKILL_LOAD_TOOL = 'skill_load';
+export function parseArgs(raw) {
+    try {
+        const v = JSON.parse(raw || '{}');
+        return v !== null && typeof v === 'object' ? v : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function asString(v) {
+    return typeof v === 'string' ? v : undefined;
+}
+export function stringify(v) {
+    return typeof v === 'string' ? v : JSON.stringify(v ?? null);
+}
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,98 @@
+{
+    "name": "@zenera/neo",
+    "version": "1.1.0",
+    "description": "A multi-agent runtime for Node.js: agents, models, tools, skills, memory and an append-only trajectory.",
+    "keywords": [
+        "agents",
+        "ai-agents",
+        "multi-agent",
+        "llm",
+        "agent-runtime",
+        "tool-calling",
+        "openai",
+        "anthropic",
+        "gemini",
+        "typescript"
+    ],
+    "license": "MIT",
+    "publishConfig": {
+        "access": "public"
+    },
+    "author": "Andrey Ryabov",
+    "homepage": "https://github.com/andreyryabov/ZeneraNeo#readme",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/andreyryabov/ZeneraNeo.git",
+        "directory": "packages/neo"
+    },
+    "bugs": "https://github.com/andreyryabov/ZeneraNeo/issues",
+    "type": "module",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "default": "./dist/index.js"
+        },
+        "./payload-stores": {
+            "types": "./dist/payload-stores/index.d.ts",
+            "default": "./dist/payload-stores/index.js"
+        },
+        "./memory-stores": {
+            "types": "./dist/memory-stores/index.d.ts",
+            "default": "./dist/memory-stores/index.js"
+        },
+        "./skill-providers": {
+            "types": "./dist/skill-providers/index.d.ts",
+            "default": "./dist/skill-providers/index.js"
+        },
+        "./project": {
+            "types": "./dist/project/index.d.ts",
+            "default": "./dist/project/index.js"
+        },
+        "./package.json": "./package.json"
+    },
+    "sideEffects": false,
+    "files": [
+        "dist",
+        "!dist/**/*.map"
+    ],
+    "engines": {
+        "node": ">=24"
+    },
+    "scripts": {
+        "build": "tsc -b",
+        "clean": "tsc -b --clean && rm -rf dist",
+        "prepack": "tsc -b"
+    },
+    "dependencies": {
+        "yaml": "^2.9.0",
+        "zod": "^4.4.3"
+    },
+    "peerDependencies": {
+        "@anthropic-ai/sdk": "^0.120.0",
+        "@google/genai": "^2.18.0",
+        "@openrouter/sdk": "^1.2.80",
+        "openai": "^6.0.0"
+    },
+    "peerDependenciesMeta": {
+        "@anthropic-ai/sdk": {
+            "optional": true
+        },
+        "@google/genai": {
+            "optional": true
+        },
+        "@openrouter/sdk": {
+            "optional": true
+        },
+        "openai": {
+            "optional": true
+        }
+    },
+    "devDependencies": {
+        "@anthropic-ai/sdk": "^0.120.0",
+        "@google/genai": "^2.18.0",
+        "@openrouter/sdk": "^1.2.80",
+        "openai": "^6.0.0"
+    }
+}