@centerseedwu/naru-agent 0.2.0

package/dist-cjs/memory/pgvector-store.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgVectorMemoryStore = void 0;
+const math_js_1 = require("../utils/math.js");
+/**
+ * PostgreSQL + pgvector backed memory store. Requires `pg` as optional dependency.
+ */
+class PgVectorMemoryStore {
+    pool;
+    tableName;
+    dimensions;
+    initialized = false;
+    constructor(config) {
+        this.pool = config.pool;
+        this.tableName = config.tableName ?? "naru_memories";
+        this.dimensions = config.dimensions ?? 1536;
+    }
+    async ensureTable() {
+        if (this.initialized)
+            return;
+        await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS ${this.tableName} (
+        id TEXT PRIMARY KEY,
+        user_id TEXT NOT NULL,
+        content TEXT NOT NULL,
+        metadata JSONB DEFAULT '{}',
+        embedding vector(${this.dimensions}),
+        created_at TIMESTAMPTZ DEFAULT NOW(),
+        updated_at TIMESTAMPTZ DEFAULT NOW()
+      )
+    `);
+        await this.pool.query(`
+      CREATE INDEX IF NOT EXISTS idx_${this.tableName}_user_id
+      ON ${this.tableName}(user_id)
+    `);
+        this.initialized = true;
+    }
+    async add(item, embedding) {
+        await this.ensureTable();
+        await this.pool.query(`INSERT INTO ${this.tableName} (id, user_id, content, metadata, embedding, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7)
+       ON CONFLICT (id) DO UPDATE SET content = $3, metadata = $4, embedding = $5, updated_at = $7`, [
+            item.id,
+            item.userId,
+            item.content,
+            JSON.stringify(item.metadata),
+            (0, math_js_1.toVectorLiteral)(embedding),
+            item.createdAt,
+            item.updatedAt,
+        ]);
+    }
+    async search(userId, embedding, topK = 5) {
+        await this.ensureTable();
+        const result = await this.pool.query(`SELECT id, user_id, content, metadata, created_at, updated_at,
+              1 - (embedding <=> $1::vector) AS score
+       FROM ${this.tableName}
+       WHERE user_id = $2
+       ORDER BY embedding <=> $1::vector
+       LIMIT $3`, [(0, math_js_1.toVectorLiteral)(embedding), userId, topK]);
+        return result.rows.map((r) => ({
+            id: r.id,
+            userId: r.user_id,
+            content: r.content,
+            metadata: (r.metadata ?? {}),
+            score: r.score,
+            createdAt: new Date(r.created_at),
+            updatedAt: new Date(r.updated_at),
+        }));
+    }
+    async update(itemId, content, embedding) {
+        await this.ensureTable();
+        await this.pool.query(`UPDATE ${this.tableName} SET content = $1, embedding = $2, updated_at = NOW() WHERE id = $3`, [content, (0, math_js_1.toVectorLiteral)(embedding), itemId]);
+    }
+    async delete(itemId) {
+        await this.ensureTable();
+        await this.pool.query(`DELETE FROM ${this.tableName} WHERE id = $1`, [itemId]);
+    }
+    async getAll(userId) {
+        await this.ensureTable();
+        const result = await this.pool.query(`SELECT id, user_id, content, metadata, created_at, updated_at
+       FROM ${this.tableName} WHERE user_id = $1 ORDER BY created_at`, [userId]);
+        return result.rows.map((r) => ({
+            id: r.id,
+            userId: r.user_id,
+            content: r.content,
+            metadata: (r.metadata ?? {}),
+            createdAt: new Date(r.created_at),
+            updatedAt: new Date(r.updated_at),
+        }));
+    }
+}
+exports.PgVectorMemoryStore = PgVectorMemoryStore;

package/dist-cjs/orchestration/channel.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/orchestration/executor.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/orchestration/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemorySessionStateStore = exports.classifyConfirmationDisposition = exports.InMemoryPendingStateManager = exports.LLMFallbackIntentResolver = exports.DeterministicIntentResolver = exports.AgentOrchestrator = void 0;
+// Orchestrator
+var orchestrator_js_1 = require("./orchestrator.js");
+Object.defineProperty(exports, "AgentOrchestrator", { enumerable: true, get: function () { return orchestrator_js_1.AgentOrchestrator; } });
+// Intent
+var intent_js_1 = require("./intent.js");
+Object.defineProperty(exports, "DeterministicIntentResolver", { enumerable: true, get: function () { return intent_js_1.DeterministicIntentResolver; } });
+Object.defineProperty(exports, "LLMFallbackIntentResolver", { enumerable: true, get: function () { return intent_js_1.LLMFallbackIntentResolver; } });
+// Pending state
+var pending_js_1 = require("./pending.js");
+Object.defineProperty(exports, "InMemoryPendingStateManager", { enumerable: true, get: function () { return pending_js_1.InMemoryPendingStateManager; } });
+Object.defineProperty(exports, "classifyConfirmationDisposition", { enumerable: true, get: function () { return pending_js_1.classifyConfirmationDisposition; } });
+// Session state
+var session_state_js_1 = require("./session-state.js");
+Object.defineProperty(exports, "InMemorySessionStateStore", { enumerable: true, get: function () { return session_state_js_1.InMemorySessionStateStore; } });

package/dist-cjs/orchestration/intent.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Generic intent types and resolvers for the orchestration layer.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMFallbackIntentResolver = exports.DeterministicIntentResolver = void 0;
+/**
+ * DeterministicIntentResolver — fast pattern matching, no LLM calls.
+ * Returns first matching pattern or unknown with confidence 0.
+ */
+class DeterministicIntentResolver {
+    patterns;
+    constructor(patterns) {
+        this.patterns = patterns;
+    }
+    async resolve(input) {
+        for (const entry of this.patterns) {
+            if (entry.pattern.test(input.message)) {
+                return entry.intent;
+            }
+        }
+        return { object: "unknown", confidence: 0 };
+    }
+}
+exports.DeterministicIntentResolver = DeterministicIntentResolver;
+/**
+ * LLMFallbackIntentResolver — tries deterministic first, falls back to LLM classifier.
+ */
+class LLMFallbackIntentResolver {
+    primary;
+    fallbackAgent;
+    parseResponse;
+    constructor(config) {
+        this.primary = config.primary;
+        this.fallbackAgent = config.fallbackAgent;
+        this.parseResponse = config.parseResponse;
+    }
+    async resolve(input) {
+        const primaryResult = await this.primary.resolve(input);
+        if (primaryResult.object !== "unknown") {
+            return primaryResult;
+        }
+        // Fallback to LLM
+        const llmResponse = await this.fallbackAgent.chat(`Classify the intent of this message: "${input.message}". Return a JSON object with "object" (string) and "confidence" (number 0-1).`);
+        if (this.parseResponse) {
+            return this.parseResponse(llmResponse.content);
+        }
+        // Default parsing
+        try {
+            const parsed = JSON.parse(llmResponse.content);
+            return {
+                object: (parsed.object ?? "unknown"),
+                confidence: parsed.confidence ?? 0.5,
+            };
+        }
+        catch {
+            return { object: "unknown", confidence: 0 };
+        }
+    }
+}
+exports.LLMFallbackIntentResolver = LLMFallbackIntentResolver;

package/dist-cjs/orchestration/orchestrator.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentOrchestrator = void 0;
+const uuid_1 = require("uuid");
+const pending_js_1 = require("./pending.js");
+/**
+ * AgentOrchestrator — wraps one or more AgentChatDelegate instances with:
+ *   Phase 0: Pending confirmation handling
+ *   Phase 1: Intent resolution
+ *   Phase 2: Direct execution (bypass LLM)
+ *   Phase 3: Delegate routing
+ *
+ * AgentOrchestrator itself satisfies AgentChatDelegate, enabling nesting.
+ */
+class AgentOrchestrator {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async fireHook(fn) {
+        if (fn) {
+            try {
+                await fn();
+            }
+            catch {
+                // hooks do not affect main flow
+            }
+        }
+    }
+    async chat(message, options) {
+        const startTime = Date.now();
+        const traceId = (0, uuid_1.v4)();
+        const sessionId = options?.sessionId ?? null;
+        const timings = { total: 0 };
+        let phaseReached = "delegate";
+        let orchestrationIntent = null;
+        let directExecutorUsed = null;
+        let delegateUsed = null;
+        // Fire beforeMessage hook
+        await this.fireHook(this.config.lifecycleHooks?.beforeMessage
+            ? () => this.config.lifecycleHooks.beforeMessage(message, options)
+            : undefined);
+        const buildDecisionTrace = (overrides) => ({
+            traceId,
+            phaseReached: overrides.phaseReached,
+            intentResolved: overrides.orchestrationIntent,
+            timings: overrides.timings,
+            directExecutorUsed: overrides.directExecutorUsed,
+            delegateUsed: overrides.delegateUsed,
+        });
+        const buildFinalResult = (baseResult, overrides) => {
+            const decisionTrace = buildDecisionTrace(overrides);
+            return {
+                ...baseResult,
+                content: overrides.content ?? baseResult.content,
+                orchestrationIntent: overrides.orchestrationIntent,
+                decisionTrace,
+                pendingConfirmation: overrides.pendingConfirmation ?? null,
+                sessionId: overrides.sessionId !== undefined ? overrides.sessionId : (sessionId ?? baseResult.sessionId),
+            };
+        };
+        // Cache session state to avoid triple fetch within the same chat() call
+        let cachedSessionState;
+        try {
+            // === Phase 0: Pending Confirmation ===
+            if (this.config.pendingStateManager && sessionId) {
+                const pending = await this.config.pendingStateManager.getPending(sessionId);
+                if (pending) {
+                    const classifier = this.config.confirmationClassifier ?? pending_js_1.classifyConfirmationDisposition;
+                    const disposition = classifier(message);
+                    if (disposition === "confirm" || disposition === "reject") {
+                        // Handle confirmation/rejection
+                        await this.config.pendingStateManager.clearPending(sessionId);
+                        phaseReached = "pending_confirmation";
+                        timings.total = Date.now() - startTime;
+                        const confirmContent = disposition === "confirm"
+                            ? `Confirmed: ${pending.type}`
+                            : `Rejected: ${pending.type}`;
+                        const baseResult = {
+                            content: confirmContent,
+                            blocked: false,
+                            usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+                            intent: null,
+                            toolCalls: [],
+                            timings: { total: timings.total },
+                            sessionId,
+                            traceId,
+                            trace: null,
+                        };
+                        const result = buildFinalResult(baseResult, {
+                            phaseReached,
+                            orchestrationIntent: null,
+                            timings,
+                            directExecutorUsed: null,
+                            delegateUsed: null,
+                            pendingConfirmation: null,
+                        });
+                        await this.fireHook(this.config.lifecycleHooks?.afterMessage
+                            ? () => this.config.lifecycleHooks.afterMessage(result)
+                            : undefined);
+                        return result;
+                    }
+                    // override — clear pending, continue normal flow
+                    await this.config.pendingStateManager.clearPending(sessionId);
+                }
+            }
+            // === Phase 1: Intent Resolution ===
+            if (this.config.intentResolver) {
+                const intentStart = Date.now();
+                if (this.config.sessionStateStore && sessionId && cachedSessionState === undefined) {
+                    cachedSessionState = await this.config.sessionStateStore.get(sessionId);
+                }
+                orchestrationIntent = await this.config.intentResolver.resolve({
+                    message,
+                    sessionState: cachedSessionState ?? undefined,
+                });
+                timings.intentResolution = Date.now() - intentStart;
+            }
+            // === Phase 2: Direct Execution ===
+            if (this.config.directExecutors && orchestrationIntent) {
+                const execStart = Date.now();
+                for (const executor of this.config.directExecutors) {
+                    if (executor.canHandle(orchestrationIntent)) {
+                        const execResult = await executor.execute({
+                            message,
+                            intent: orchestrationIntent,
+                            options: options,
+                        });
+                        if (execResult !== null) {
+                            phaseReached = "direct_execution";
+                            directExecutorUsed = executor.name;
+                            timings.directExecution = Date.now() - execStart;
+                            timings.total = Date.now() - startTime;
+                            const result = buildFinalResult(execResult, {
+                                phaseReached,
+                                orchestrationIntent,
+                                timings,
+                                directExecutorUsed,
+                                delegateUsed: null,
+                            });
+                            await this.fireHook(this.config.lifecycleHooks?.afterMessage
+                                ? () => this.config.lifecycleHooks.afterMessage(result)
+                                : undefined);
+                            return result;
+                        }
+                    }
+                }
+            }
+            // === Phase 3: Delegate Routing ===
+            const delegateStart = Date.now();
+            let selectedDelegate = this.config.delegate;
+            let selectedDelegateName = "default";
+            if (orchestrationIntent && this.config.delegates) {
+                const mapped = this.config.delegates.get(orchestrationIntent.object);
+                if (mapped) {
+                    selectedDelegate = mapped;
+                    selectedDelegateName = orchestrationIntent.object;
+                }
+            }
+            // Enrich options with session state if available (use cached fetch)
+            let enrichedOptions = options;
+            if (this.config.sessionStateStore && sessionId) {
+                if (cachedSessionState === undefined) {
+                    cachedSessionState = await this.config.sessionStateStore.get(sessionId);
+                }
+                if (cachedSessionState) {
+                    enrichedOptions = { ...options, sessionState: cachedSessionState };
+                }
+            }
+            const delegateResult = await selectedDelegate.chat(message, enrichedOptions);
+            timings.delegate = Date.now() - delegateStart;
+            timings.total = Date.now() - startTime;
+            phaseReached = "delegate";
+            delegateUsed = selectedDelegateName;
+            // Update session state if applicable (reuse cached session state)
+            if (this.config.sessionStateStore && sessionId && delegateResult.sessionId) {
+                const newState = {
+                    sessionId,
+                    lastPresentedEntities: cachedSessionState?.lastPresentedEntities ?? [],
+                    metadata: cachedSessionState?.metadata ?? {},
+                    updatedAt: Date.now(),
+                };
+                await this.config.sessionStateStore.save(sessionId, newState);
+            }
+            const result = buildFinalResult(delegateResult, {
+                phaseReached,
+                orchestrationIntent,
+                timings,
+                directExecutorUsed,
+                delegateUsed,
+                sessionId: sessionId ?? delegateResult.sessionId,
+            });
+            await this.fireHook(this.config.lifecycleHooks?.afterMessage
+                ? () => this.config.lifecycleHooks.afterMessage(result)
+                : undefined);
+            return result;
+        }
+        catch (error) {
+            // Fire onError hook
+            await this.fireHook(this.config.lifecycleHooks?.onError
+                ? () => this.config.lifecycleHooks.onError(error)
+                : undefined);
+            // Re-throw after hook
+            throw error;
+        }
+    }
+    /**
+     * Process a channel-specific raw input through the channel adapter.
+     */
+    async processChannel(rawInput) {
+        if (!this.config.channelAdapter) {
+            throw new Error("No channelAdapter configured");
+        }
+        const channelMessage = this.config.channelAdapter.parseIncoming(rawInput);
+        const result = await this.chat(channelMessage.text, channelMessage.options);
+        return this.config.channelAdapter.formatOutgoing(result);
+    }
+}
+exports.AgentOrchestrator = AgentOrchestrator;

package/dist-cjs/orchestration/pending.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Pending state management — tracks confirmations awaiting user response.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryPendingStateManager = void 0;
+exports.classifyConfirmationDisposition = classifyConfirmationDisposition;
+/**
+ * InMemoryPendingStateManager — simple in-memory Map implementation.
+ */
+class InMemoryPendingStateManager {
+    store = new Map();
+    async getPending(sessionId) {
+        return this.store.get(sessionId) ?? null;
+    }
+    async setPending(sessionId, state) {
+        this.store.set(sessionId, state);
+    }
+    async clearPending(sessionId) {
+        this.store.delete(sessionId);
+    }
+}
+exports.InMemoryPendingStateManager = InMemoryPendingStateManager;
+const CONFIRM_PATTERN = /^(好|確認|對|yes|y|ok|好的|是|沒問題|sure|confirm)$/i;
+const REJECT_PATTERN = /^(不要|取消|no|n|不|cancel|否|算了|不行|reject)$/i;
+/**
+ * Default implementation to classify a user message's disposition toward a pending confirmation.
+ */
+function classifyConfirmationDisposition(message) {
+    const trimmed = message.trim();
+    if (CONFIRM_PATTERN.test(trimmed))
+        return "confirm";
+    if (REJECT_PATTERN.test(trimmed))
+        return "reject";
+    return "override";
+}

package/dist-cjs/orchestration/result.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/orchestration/session-state.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * AgentSessionState — tracks entities presented in the last response for coreference resolution.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemorySessionStateStore = void 0;
+/**
+ * InMemorySessionStateStore — simple in-memory Map implementation.
+ */
+class InMemorySessionStateStore {
+    store = new Map();
+    async get(sessionId) {
+        return this.store.get(sessionId) ?? null;
+    }
+    async save(sessionId, state) {
+        this.store.set(sessionId, state);
+    }
+    async clear(sessionId) {
+        this.store.delete(sessionId);
+    }
+}
+exports.InMemorySessionStateStore = InMemorySessionStateStore;

package/dist-cjs/orchestration/trace.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/session/base.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/session/in-memory-store.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemorySessionStore = void 0;
+class InMemorySessionStore {
+    store = new Map();
+    async get(sessionId) {
+        return this.store.get(sessionId) ?? null;
+    }
+    async save(sessionId, history) {
+        this.store.set(sessionId, history);
+    }
+    async delete(sessionId) {
+        this.store.delete(sessionId);
+    }
+}
+exports.InMemorySessionStore = InMemorySessionStore;

package/dist-cjs/session/redis-store.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisSessionStore = void 0;
+/**
+ * Redis-backed session store. Requires `ioredis` as optional dependency.
+ */
+class RedisSessionStore {
+    redis;
+    prefix;
+    ttlSeconds;
+    constructor(redis, prefix = "naru:session:", ttlSeconds = 86400) {
+        this.redis = redis;
+        this.prefix = prefix;
+        this.ttlSeconds = ttlSeconds;
+    }
+    key(sessionId) {
+        return `${this.prefix}${sessionId}`;
+    }
+    async get(sessionId) {
+        const data = await this.redis.get(this.key(sessionId));
+        if (!data)
+            return null;
+        return JSON.parse(data);
+    }
+    async save(sessionId, history) {
+        await this.redis.set(this.key(sessionId), JSON.stringify(history), "EX", this.ttlSeconds);
+    }
+    async delete(sessionId) {
+        await this.redis.del(this.key(sessionId));
+    }
+}
+exports.RedisSessionStore = RedisSessionStore;

package/dist-cjs/skills/base.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skill = skill;
+exports.makeSkillResult = makeSkillResult;
+/**
+ * Factory function to create a skill (equivalent to Python @skill decorator).
+ */
+function skill(config) {
+    return {
+        name: config.name,
+        description: config.description ?? "",
+        triggers: config.triggers ?? [],
+        priority: config.priority ?? 0,
+        alwaysActive: config.alwaysActive ?? false,
+        run: config.run,
+    };
+}
+function makeSkillResult(partial) {
+    return {
+        promptInjection: "",
+        extraTools: [],
+        overrideSystemPrompt: null,
+        skillName: "",
+        skipped: false,
+        ...partial,
+    };
+}

package/dist-cjs/skills/registry.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillRegistry = void 0;
+const selectors_js_1 = require("./selectors.js");
+const base_js_1 = require("./base.js");
+class SkillRegistry {
+    skills;
+    selector;
+    maxActiveSkills;
+    constructor(skills, selector, maxActiveSkills = 3) {
+        this.skills = skills;
+        this.selector = selector ?? new selectors_js_1.KeywordSkillSelector();
+        this.maxActiveSkills = maxActiveSkills;
+    }
+    async selectSkills(message) {
+        const selected = await this.selector.select(this.skills, message);
+        return selected
+            .sort((a, b) => b.priority - a.priority)
+            .slice(0, this.maxActiveSkills);
+    }
+    async runSkills(message, context) {
+        const selected = await this.selectSkills(message);
+        if (selected.length === 0)
+            return [];
+        const results = await Promise.allSettled(selected.map(async (s) => {
+            try {
+                const result = await s.run(message, context);
+                return { ...result, skillName: s.name };
+            }
+            catch {
+                return (0, base_js_1.makeSkillResult)({ skillName: s.name, skipped: true });
+            }
+        }));
+        return results
+            .filter((r) => r.status === "fulfilled")
+            .map((r) => r.value)
+            .filter((r) => !r.skipped);
+    }
+}
+exports.SkillRegistry = SkillRegistry;

package/dist-cjs/skills/selectors.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbeddingSkillSelector = exports.KeywordSkillSelector = void 0;
+const math_js_1 = require("../utils/math.js");
+/**
+ * Case-insensitive keyword matching on skill triggers.
+ */
+class KeywordSkillSelector {
+    async select(skills, message) {
+        const lower = message.toLowerCase();
+        return skills.filter((s) => s.alwaysActive ||
+            s.triggers.some((t) => lower.includes(t.toLowerCase())));
+    }
+}
+exports.KeywordSkillSelector = KeywordSkillSelector;
+/**
+ * Embedding-based similarity matching for skill selection.
+ */
+class EmbeddingSkillSelector {
+    embedFn;
+    topK;
+    similarityThreshold;
+    cachedEmbeddings = null;
+    constructor(embedFn, topK = 2, similarityThreshold = 0.45) {
+        this.embedFn = embedFn;
+        this.topK = topK;
+        this.similarityThreshold = similarityThreshold;
+    }
+    async select(skills, message) {
+        const alwaysActive = skills.filter((s) => s.alwaysActive);
+        const candidates = skills.filter((s) => !s.alwaysActive);
+        if (candidates.length === 0)
+            return alwaysActive;
+        // Build skill description embeddings (cached)
+        if (!this.cachedEmbeddings) {
+            const descriptions = candidates.map((s) => `${s.name}: ${s.description} ${s.triggers.join(" ")}`);
+            const embeddings = await this.embedFn(descriptions);
+            this.cachedEmbeddings = new Map();
+            for (let i = 0; i < candidates.length; i++) {
+                this.cachedEmbeddings.set(candidates[i].name, embeddings[i]);
+            }
+        }
+        const [queryEmbed] = await this.embedFn([message]);
+        const scored = candidates
+            .map((s) => ({
+            skill: s,
+            score: (0, math_js_1.cosineSimilarity)(queryEmbed, this.cachedEmbeddings.get(s.name)),
+        }))
+            .filter((x) => x.score >= this.similarityThreshold)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, this.topK)
+            .map((x) => x.skill);
+        return [...alwaysActive, ...scored];
+    }
+}
+exports.EmbeddingSkillSelector = EmbeddingSkillSelector;

package/dist-cjs/tools/base.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tool = tool;
+/**
+ * Factory function to create a tool (equivalent to Python @tool decorator).
+ *
+ * @example
+ * const weatherTool = tool({
+ *   name: "get_weather",
+ *   description: "Get weather for a city",
+ *   parameters: z.object({ city: z.string() }),
+ *   execute: async ({ city }) => `Weather in ${city}: sunny`,
+ * });
+ */
+function tool(config) {
+    return {
+        name: config.name,
+        description: config.description,
+        parameters: config.parameters,
+        execute: config.execute,
+        timeout: config.timeout,
+        retries: config.retries,
+    };
+}