@juspay/neurolink 9.84.2 → 9.85.0

package/dist/skills/skillTools.js

@@ -0,0 +1,339 @@
+/**
+ * Built-in skill tools, following the createMemoryRetrievalTools /
+ * createFileTools / createTaskTools factory pattern.
+ *
+ * The manager is resolved lazily via a resolver callback so tools can be
+ * registered at construction time while the store initializes on first
+ * use (mirrors how retrieve_context resolves conversationMemory lazily).
+ *
+ * Tool descriptions are ported from curator's production skills tools —
+ * the "always check skills first / no_match is expected, not an error /
+ * pick the best of 2-5 or ask" prompt engineering is proven in prod.
+ */
+import { z } from "zod";
+import { logger } from "../utils/logger.js";
+import { tool } from "../utils/tool.js";
+/** Trim a hydrated skill to the fields the model needs. */
+function toToolSkill(skill) {
+    return {
+        id: skill.id,
+        name: skill.name,
+        ...(skill.displayName ? { displayName: skill.displayName } : {}),
+        description: skill.description,
+        instructions: skill.instructions,
+        tags: skill.tags ?? [],
+        scope: skill.scope ?? "global",
+        version: skill.version ?? 1,
+    };
+}
+/**
+ * Create the built-in skill tools bound to a lazily-resolved manager.
+ * Returns Vercel AI SDK tool() objects (description + Zod inputSchema +
+ * execute) keyed by tool name.
+ */
+export function createSkillTools(resolveManager, options) {
+    const notConfigured = {
+        success: false,
+        error: "Skills are not available — the skills store failed to initialize. " +
+            "Answer from general knowledge.",
+        data: { skills: [] },
+    };
+    const tools = {
+        search_skills: tool({
+            description: "ALWAYS call this at the start of every user request before answering from general knowledge. " +
+                "Searches team-defined skills (SOPs, playbooks, workflows) using an index-first approach — " +
+                "fast, low-cost, and does not load skills that do not match. " +
+                "You MUST provide at least one of: query (keyword from the user message) or tag (domain category). " +
+                "If 1 match is found, follow its instructions exactly. " +
+                "If 2-5 matches are found, use your judgment based on the user message to pick the best one, " +
+                "or ask the user to clarify if the instructions would lead to meaningfully different actions. " +
+                "Only skip this call for purely conversational messages like greetings. " +
+                'Returns `{ skills: [], reason: "no_match" }` when nothing matches — this is expected, NOT an ' +
+                "error. In that case, answer from general knowledge.",
+            inputSchema: z.object({
+                query: z
+                    .string()
+                    .optional()
+                    .describe("Keyword from the user message, matched against skill name, display name, and description. " +
+                    'E.g. "deployment", "refund process", "on-call escalation".'),
+                tag: z
+                    .string()
+                    .optional()
+                    .describe('Domain category tag to narrow results (e.g. "payments", "devops"). ' +
+                    "Applied on top of the query filter when both are provided."),
+                scopeId: z
+                    .string()
+                    .optional()
+                    .describe("Scope identifier (channel/team/tenant id) to include scoped skills alongside global ones. " +
+                    "Usually omit — the host default applies."),
+            }),
+            execute: async (args) => {
+                if (!args.query && !args.tag) {
+                    return {
+                        success: false,
+                        error: 'At least one of "query" or "tag" must be provided to search_skills.',
+                        data: { skills: [] },
+                    };
+                }
+                const manager = resolveManager();
+                if (!manager) {
+                    return notConfigured;
+                }
+                try {
+                    const skills = await manager.search(args);
+                    if (skills.length === 0) {
+                        return {
+                            success: true,
+                            data: {
+                                skills: [],
+                                reason: "no_match",
+                                message: `No skills found${args.query ? ` matching "${args.query}"` : ""}${args.tag ? ` with tag "${args.tag}"` : ""}. Answer from general knowledge.`,
+                            },
+                        };
+                    }
+                    return {
+                        success: true,
+                        data: {
+                            skills: skills.map(toToolSkill),
+                            count: skills.length,
+                            ...(skills.length > 1
+                                ? {
+                                    hint: "Multiple skills matched. Pick the most relevant one for the user message, or ask the user to clarify.",
+                                }
+                                : {}),
+                        },
+                    };
+                }
+                catch (error) {
+                    logger.warn("[SkillTools] search_skills failed", {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                    return {
+                        success: false,
+                        error: error instanceof Error ? error.message : String(error),
+                        data: { skills: [] },
+                    };
+                }
+            },
+        }),
+        list_skills: tool({
+            description: "Returns a lightweight list of all available skills — name, display name, description, and " +
+                "tags only. No instructions are returned, keeping context cost minimal. " +
+                'Use this only when a user explicitly asks "what skills do you have?" or "what can you help ' +
+                'me with?". Do NOT use this for skill lookup before answering — use search_skills instead.',
+            inputSchema: z.object({
+                scopeId: z
+                    .string()
+                    .optional()
+                    .describe("Scope identifier to include scoped skills alongside global ones. Usually omit."),
+            }),
+            execute: async (args) => {
+                const manager = resolveManager();
+                if (!manager) {
+                    return notConfigured;
+                }
+                try {
+                    const items = await manager.list(args.scopeId);
+                    return {
+                        success: true,
+                        data: {
+                            skills: items.map((item) => ({
+                                name: item.name,
+                                ...(item.displayName ? { displayName: item.displayName } : {}),
+                                description: item.description,
+                                tags: item.tags ?? [],
+                                scope: item.scope ?? "global",
+                            })),
+                            count: items.length,
+                        },
+                    };
+                }
+                catch (error) {
+                    logger.warn("[SkillTools] list_skills failed", {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                    return {
+                        success: false,
+                        error: error instanceof Error ? error.message : String(error),
+                        data: { skills: [] },
+                    };
+                }
+            },
+        }),
+    };
+    if (options?.allowMutations) {
+        Object.assign(tools, createSkillMutationTools(resolveManager));
+    }
+    return tools;
+}
+/** Shared executor for the three mutation tools. */
+async function runMutation(resolveManager, action) {
+    const manager = resolveManager();
+    if (!manager) {
+        return {
+            success: false,
+            error: "Skills are not available — the skills store failed to initialize.",
+        };
+    }
+    try {
+        const result = await manager.requestMutation(action);
+        if (result.decision.outcome === "rejected") {
+            return {
+                success: false,
+                error: `Skill ${action.type} was rejected${result.decision.reason ? `: ${result.decision.reason}` : "."}`,
+            };
+        }
+        if (result.decision.outcome === "pending") {
+            return {
+                success: true,
+                data: {
+                    status: "pending_approval",
+                    ...(result.decision.reference
+                        ? { reference: result.decision.reference }
+                        : {}),
+                    message: `Skill ${action.type} was submitted for approval. It takes effect once an approver accepts it.`,
+                },
+            };
+        }
+        return {
+            success: true,
+            data: {
+                status: "applied",
+                ...(result.skill
+                    ? {
+                        skillId: result.skill.id,
+                        name: result.skill.name,
+                        version: result.skill.version,
+                        skillStatus: result.skill.status,
+                    }
+                    : {}),
+            },
+        };
+    }
+    catch (error) {
+        logger.warn(`[SkillTools] skill_${action.type} failed`, {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function createSkillMutationTools(resolveManager) {
+    const scopeFields = {
+        scope: z
+            .enum(["global", "scoped"])
+            .optional()
+            .describe('"global" = available everywhere; "scoped" = only for specific scope ids.'),
+        scopeIds: z
+            .array(z.string())
+            .optional()
+            .describe('Required when scope="scoped": the scope ids (channel/team/tenant) the skill applies to.'),
+    };
+    return {
+        skill_create: tool({
+            description: "Propose a NEW skill (SOP/playbook). Depending on host configuration the skill is either " +
+                "applied immediately or queued for human approval. " +
+                "INVOKE ONLY WHEN the user explicitly asks to create a new skill and has supplied the name, " +
+                "description, and full instructions text. DO NOT INVENT CONTENT — the instructions must come " +
+                "from the user verbatim or nearly so. If the user has not given the full text, ask. " +
+                "Do not use this to modify an existing skill (use skill_update).",
+            inputSchema: z.object({
+                name: z
+                    .string()
+                    .min(1)
+                    .describe('Short machine-friendly skill name (snake_case recommended), unique. E.g. "refund_dispute_escalation".'),
+                displayName: z
+                    .string()
+                    .optional()
+                    .describe('Human-readable display name. E.g. "Refund Dispute Escalation".'),
+                description: z
+                    .string()
+                    .min(1)
+                    .describe("One or two sentences explaining when this skill applies. Used for matching."),
+                instructions: z
+                    .string()
+                    .min(1)
+                    .describe("The full step-by-step instructions to follow when this skill matches. " +
+                    "Must come from the user — do not invent steps."),
+                tags: z
+                    .array(z.string())
+                    .optional()
+                    .describe('Domain tags for filtering (e.g. ["payments", "escalation"]).'),
+                ...scopeFields,
+                requestedBy: z
+                    .string()
+                    .optional()
+                    .describe("Identifier of the requesting user, when known."),
+            }),
+            execute: async (args) => {
+                if (args.scope === "scoped" && (args.scopeIds ?? []).length === 0) {
+                    return {
+                        success: false,
+                        error: '"scopeIds" must contain at least one scope id when scope="scoped".',
+                    };
+                }
+                const { requestedBy, ...skill } = args;
+                return runMutation(resolveManager, {
+                    type: "create",
+                    skill,
+                    ...(requestedBy ? { requestedBy } : {}),
+                });
+            },
+        }),
+        skill_update: tool({
+            description: "Propose an update to an EXISTING skill. Only the provided fields change; the version is " +
+                "bumped. Depending on host configuration the change is applied immediately or queued for " +
+                "human approval. Look the skill up with search_skills or list_skills first to get its id or " +
+                "exact name. Do not paraphrase or expand the user's instructions.",
+            inputSchema: z.object({
+                skillId: z
+                    .string()
+                    .min(1)
+                    .describe("Id (or exact unique name) of the skill to update."),
+                displayName: z.string().optional(),
+                description: z.string().optional(),
+                instructions: z
+                    .string()
+                    .optional()
+                    .describe("Replacement instructions text, verbatim from the user."),
+                tags: z.array(z.string()).optional(),
+                ...scopeFields,
+                requestedBy: z.string().optional(),
+            }),
+            execute: async (args) => {
+                const { skillId, requestedBy, ...patch } = args;
+                if (Object.values(patch).every((v) => v === undefined)) {
+                    return {
+                        success: false,
+                        error: "Provide at least one field to update.",
+                    };
+                }
+                return runMutation(resolveManager, {
+                    type: "update",
+                    skillId,
+                    patch,
+                    ...(requestedBy ? { requestedBy } : {}),
+                });
+            },
+        }),
+        skill_delete: tool({
+            description: "Propose deleting (deprecating) an EXISTING skill. The skill stops matching but stays in " +
+                "storage for audit. Depending on host configuration this is applied immediately or queued " +
+                "for human approval. INVOKE ONLY WHEN the user explicitly asks to delete a skill.",
+            inputSchema: z.object({
+                skillId: z
+                    .string()
+                    .min(1)
+                    .describe("Id (or exact unique name) of the skill to delete."),
+                requestedBy: z.string().optional(),
+            }),
+            execute: async (args) => runMutation(resolveManager, {
+                type: "delete",
+                skillId: args.skillId,
+                ...(args.requestedBy ? { requestedBy: args.requestedBy } : {}),
+            }),
+        }),
+    };
+}

package/dist/skills/skillsManager.d.ts

@@ -0,0 +1,54 @@
+/**
+ * SkillsManager — orchestrates the skill store, cached index, index-first
+ * search (hydrating instructions only for matches), prompt-index rendering,
+ * and the mutation gate.
+ *
+ * Read paths fail open (errors surface as empty results + a warn log);
+ * write paths fail closed (errors reject the mutation).
+ */
+import type { SkillDefinition, SkillIndexItem, SkillMutationAction, SkillMutationResult, SkillSearchQuery, SkillsConfig } from "../types/index.js";
+export declare class SkillsManager {
+    private readonly config;
+    private readonly store;
+    private cachedIndex;
+    private cachedIndexAt;
+    /** Serializes writes within this process — see requestMutation(). */
+    private mutationQueue;
+    constructor(config: SkillsConfig);
+    /** Cached index read. TTL 0 disables caching. */
+    getIndex(forceRefresh?: boolean): Promise<SkillIndexItem[]>;
+    private invalidateIndex;
+    /**
+     * Index-first search: filter the cached index, hydrate only the matched
+     * entries (max `limit`) with instructions. Cost: one cached index read +
+     * N_matched store gets.
+     */
+    search(query: SkillSearchQuery): Promise<SkillDefinition[]>;
+    /** Index entries only — no instructions. For discovery/listing. */
+    list(scopeId?: string): Promise<SkillIndexItem[]>;
+    /** Fetch one skill by id, falling back to name lookup. */
+    get(idOrName: string): Promise<SkillDefinition | null>;
+    /**
+     * Render the system-prompt skills index for one call, or null when
+     * nothing is visible. Never includes instructions.
+     */
+    buildPromptIndex(options?: {
+        scopeId?: string;
+        tags?: string[];
+    }): Promise<string | null>;
+    /**
+     * Whether skill create/update/delete is enabled on this instance. Gates the
+     * LLM-facing `skill_*` tools (registration) and the server REST mutation
+     * routes. Direct programmatic `requestMutation` calls are intentionally not
+     * gated, so a host can still seed skills at startup.
+     */
+    get mutationsAllowed(): boolean;
+    /**
+     * Gate a proposed mutation through the host's onMutationRequest hook,
+     * then apply it when approved. No hook configured means direct apply
+     * (the tools themselves are already gated by allowMutations).
+     */
+    requestMutation(action: SkillMutationAction): Promise<SkillMutationResult>;
+    private applyMutation;
+    private assertNameAvailable;
+}

package/dist/skills/skillsManager.js

@@ -0,0 +1,219 @@
+/**
+ * SkillsManager — orchestrates the skill store, cached index, index-first
+ * search (hydrating instructions only for matches), prompt-index rendering,
+ * and the mutation gate.
+ *
+ * Read paths fail open (errors surface as empty results + a warn log);
+ * write paths fail closed (errors reject the mutation).
+ */
+import { randomUUID } from "node:crypto";
+import { logger } from "../utils/logger.js";
+import { filterSkillIndex, formatSkillsPromptIndex } from "./skillMatcher.js";
+import { createSkillStore } from "./skillStores.js";
+const DEFAULT_MAX_MATCHES = 5;
+const DEFAULT_PROMPT_INDEX_MAX_ITEMS = 50;
+const DEFAULT_INDEX_CACHE_TTL_MS = 30_000;
+export class SkillsManager {
+    config;
+    store;
+    cachedIndex = null;
+    cachedIndexAt = 0;
+    /** Serializes writes within this process — see requestMutation(). */
+    mutationQueue = Promise.resolve();
+    constructor(config) {
+        this.config = config;
+        this.store = createSkillStore(config.storage);
+    }
+    /** Cached index read. TTL 0 disables caching. */
+    async getIndex(forceRefresh = false) {
+        const ttl = this.config.indexCacheTtlMs ?? DEFAULT_INDEX_CACHE_TTL_MS;
+        const fresh = this.cachedIndex !== null &&
+            ttl > 0 &&
+            Date.now() - this.cachedIndexAt < ttl;
+        if (fresh && !forceRefresh && this.cachedIndex) {
+            return this.cachedIndex;
+        }
+        const index = await this.store.index();
+        this.cachedIndex = index;
+        this.cachedIndexAt = Date.now();
+        return index;
+    }
+    invalidateIndex() {
+        this.cachedIndex = null;
+        this.store.invalidate?.();
+    }
+    /**
+     * Index-first search: filter the cached index, hydrate only the matched
+     * entries (max `limit`) with instructions. Cost: one cached index read +
+     * N_matched store gets.
+     */
+    async search(query) {
+        const limit = query.limit ?? this.config.maxMatches ?? DEFAULT_MAX_MATCHES;
+        const scopeId = query.scopeId ?? this.config.defaultScopeId;
+        const index = await this.getIndex();
+        const matched = filterSkillIndex(index, {
+            ...query,
+            ...(scopeId !== undefined ? { scopeId } : {}),
+            limit,
+        });
+        const hydrated = await Promise.all(matched.map((item) => this.store.get(item.id)));
+        return hydrated.filter((s) => s !== null);
+    }
+    /** Index entries only — no instructions. For discovery/listing. */
+    async list(scopeId) {
+        const effectiveScopeId = scopeId ?? this.config.defaultScopeId;
+        const index = await this.getIndex();
+        return filterSkillIndex(index, {
+            ...(effectiveScopeId !== undefined ? { scopeId: effectiveScopeId } : {}),
+        });
+    }
+    /** Fetch one skill by id, falling back to name lookup. */
+    async get(idOrName) {
+        const byId = await this.store.get(idOrName);
+        if (byId) {
+            return byId;
+        }
+        const index = await this.getIndex();
+        // Prefer an active skill when resolving by name: a soft-deleted skill and a
+        // later same-named active skill can coexist in the index, so a bare
+        // name-find would resolve non-deterministically to the stale deprecated one
+        // across store backends. Fall back to any match only when no active skill
+        // carries the name.
+        const entry = index.find((item) => item.name === idOrName && (item.status ?? "active") === "active") ?? index.find((item) => item.name === idOrName);
+        return entry ? this.store.get(entry.id) : null;
+    }
+    /**
+     * Render the system-prompt skills index for one call, or null when
+     * nothing is visible. Never includes instructions.
+     */
+    async buildPromptIndex(options) {
+        let items = await this.list(options?.scopeId);
+        if (options?.tags && options.tags.length > 0) {
+            const wanted = options.tags.map((t) => t.toLowerCase());
+            items = items.filter((item) => (item.tags ?? []).some((t) => wanted.includes(t.toLowerCase())));
+        }
+        return formatSkillsPromptIndex(items, this.config.promptIndexMaxItems ?? DEFAULT_PROMPT_INDEX_MAX_ITEMS);
+    }
+    /**
+     * Whether skill create/update/delete is enabled on this instance. Gates the
+     * LLM-facing `skill_*` tools (registration) and the server REST mutation
+     * routes. Direct programmatic `requestMutation` calls are intentionally not
+     * gated, so a host can still seed skills at startup.
+     */
+    get mutationsAllowed() {
+        return this.config.allowMutations ?? false;
+    }
+    /**
+     * Gate a proposed mutation through the host's onMutationRequest hook,
+     * then apply it when approved. No hook configured means direct apply
+     * (the tools themselves are already gated by allowMutations).
+     */
+    async requestMutation(action) {
+        let decision = { outcome: "approved" };
+        if (this.config.onMutationRequest) {
+            decision = await this.config.onMutationRequest(action);
+        }
+        if (decision.outcome !== "approved") {
+            return { decision };
+        }
+        // Serialize writes within this process so the name-uniqueness check and
+        // the store write can never interleave across concurrent mutations.
+        // Cross-process races remain possible with plain-object stores (S3,
+        // Redis) — hosts needing strict global uniqueness should serialize via
+        // their onMutationRequest gate; the S3 index additionally self-heals.
+        const run = this.mutationQueue.then(() => this.applyMutation(action));
+        this.mutationQueue = run.catch(() => undefined);
+        const skill = await run;
+        return { decision, ...(skill ? { skill } : {}) };
+    }
+    async applyMutation(action) {
+        const now = new Date().toISOString();
+        if (action.type === "create") {
+            await this.assertNameAvailable(action.skill.name);
+            const skill = {
+                id: randomUUID(),
+                version: 1,
+                status: "active",
+                createdAt: now,
+                updatedAt: now,
+                ...action.skill,
+            };
+            assertScopeConsistent(skill);
+            await this.store.put(skill);
+            this.invalidateIndex();
+            logger.info("[SkillsManager] Skill created", {
+                skillId: skill.id,
+                name: skill.name,
+            });
+            return skill;
+        }
+        if (action.type === "update") {
+            const existing = await this.get(action.skillId);
+            if (!existing) {
+                throw new Error(`Skill "${action.skillId}" not found`);
+            }
+            if (action.patch.name && action.patch.name !== existing.name) {
+                await this.assertNameAvailable(action.patch.name, existing.id);
+            }
+            const updated = {
+                ...existing,
+                ...definedFields(action.patch),
+                id: existing.id,
+                version: (existing.version ?? 1) + 1,
+                updatedAt: now,
+            };
+            assertScopeConsistent(updated);
+            await this.store.put(updated);
+            this.invalidateIndex();
+            logger.info("[SkillsManager] Skill updated", {
+                skillId: updated.id,
+                version: updated.version,
+            });
+            return updated;
+        }
+        // delete — soft: mark deprecated so the skill drops out of active
+        // listings but stays in storage for audit/undo.
+        const existing = await this.get(action.skillId);
+        if (!existing) {
+            throw new Error(`Skill "${action.skillId}" not found`);
+        }
+        if (existing.status === "deprecated") {
+            throw new Error(`Skill "${existing.name}" is already deleted`);
+        }
+        const deprecated = {
+            ...existing,
+            status: "deprecated",
+            updatedAt: now,
+        };
+        await this.store.put(deprecated);
+        this.invalidateIndex();
+        logger.info("[SkillsManager] Skill deprecated", {
+            skillId: existing.id,
+            name: existing.name,
+        });
+        return deprecated;
+    }
+    async assertNameAvailable(name, excludeId) {
+        const index = await this.getIndex(true);
+        const clash = index.find((item) => item.id !== excludeId &&
+            item.name.toLowerCase() === name.toLowerCase() &&
+            (item.status ?? "active") === "active");
+        if (clash) {
+            throw new Error(`A skill named "${name}" already exists`);
+        }
+    }
+}
+/**
+ * A scoped skill without scopeIds can never match anything — reject the
+ * write instead of persisting an unmatchable skill. Validated post-merge so
+ * both create and patch-style update paths are covered.
+ */
+function assertScopeConsistent(skill) {
+    if (skill.scope === "scoped" && (skill.scopeIds ?? []).length === 0) {
+        throw new Error('A skill with scope "scoped" must have at least one entry in scopeIds');
+    }
+}
+/** Shallow-copy only the defined fields of a patch (undefined must not overwrite). */
+function definedFields(patch) {
+    return Object.fromEntries(Object.entries(patch).filter(([, value]) => value !== undefined));
+}

package/dist/types/config.d.ts

@@ -12,6 +12,7 @@ import type { NeurolinkCredentials } from "./providers.js";
 import type { ModelPoolConfig } from "./modelPool.js";
 import type { RequestRouter } from "./requestRouter.js";
 import type { ClassifierRouterConfig } from "./classifierRouter.js";
+import type { SkillsConfig } from "./skills.js";
 /**
  * Main NeuroLink configuration type
  */
@@ -114,6 +115,15 @@ export type NeurolinkConstructorConfig = {
      * caller pinned both `provider` and `model`. See {@link ClassifierRouterConfig}.
      */
     classifierRouter?: ClassifierRouterConfig;
+    /**
+     * Native skills: versioned, discoverable instruction packs (SOPs,
+     * playbooks) with progressive disclosure. When enabled, built-in
+     * search_skills / list_skills tools are registered (plus gated mutation
+     * tools) and a compact skills index is injected into the system prompt
+     * of each generate()/stream() call. Opt-in and fails open on read paths.
+     * See {@link SkillsConfig}.
+     */
+    skills?: SkillsConfig;
 };
 /**
  * Configuration for MCP enhancement modules wired into generate()/stream() paths.

package/dist/types/generate.d.ts

@@ -1,5 +1,6 @@
 import type { AIProviderName } from "../constants/enums.js";
 import type { RAGConfig } from "./rag.js";
+import type { SkillsCallOptions } from "./skills.js";
 import type { AnalyticsData, TokenUsage } from "./analytics.js";
 import type { JsonValue } from "./common.js";
 import type { Content, ImageWithAltText } from "./content.js";
@@ -615,6 +616,13 @@ export type GenerateOptions = {
      * @deprecated Use `piiDetection`, `responseValidation`, and `inputValidation` instead.
      */
     processors?: ProcessorPipelineConfig;
+    /**
+     * Per-call skills control. Only effective when the instance was
+     * constructed with `skills.enabled: true`. Lets a call disable the
+     * prompt index, or narrow it by scope/tags. Per-call wins over
+     * instance config.
+     */
+    skills?: SkillsCallOptions;
 };
 /**
  * Represents an additional user whose memory should be included in a generate/stream call.

package/dist/types/index.d.ts

@@ -46,6 +46,7 @@ export * from "./scorer.js";
 export * from "./sdk.js";
 export * from "./server.js";
 export * from "./service.js";
+export * from "./skills.js";
 export * from "./stream.js";
 export * from "./subscription.js";
 export * from "./task.js";

package/dist/types/index.js

@@ -47,6 +47,7 @@ export * from "./scorer.js";
 export * from "./sdk.js";
 export * from "./server.js";
 export * from "./service.js";
+export * from "./skills.js";
 export * from "./stream.js";
 export * from "./subscription.js";
 export * from "./task.js";