agent-framework-js 0.1.1

package/dist/provider-CMAymr1b.d.cts

@@ -0,0 +1,82 @@
+import { a as ModelCapabilities, M as Message } from './types-Cn1g9Tg4.cjs';
+
+/**
+ * LLM provider abstraction. Agents and workflows depend only on this interface,
+ * never on a concrete provider, so new providers can be added without changing
+ * agent/workflow code. (FR-007)
+ *
+ * Credentials are always obtained via a caller-supplied callback and are never
+ * bundled, persisted, or logged by the framework. (FR-005a, FR-008)
+ *
+ * @packageDocumentation
+ */
+
+/** A caller-supplied source of credentials. The framework never stores the value. */
+interface CredentialSource {
+    /** Return the current credential (token/api key). May be async. */
+    getCredential(): string | Promise<string>;
+}
+/** A tool description passed to the provider so the model can decide to call it. */
+interface ToolSpec {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+/** A request to generate a model response. */
+interface GenerateRequest {
+    messages: Message[];
+    tools?: ToolSpec[];
+    /** Abort signal to cancel an in-flight request. */
+    signal?: AbortSignal;
+}
+/** A tool call requested by the model. */
+interface ToolCall {
+    id: string;
+    name: string;
+    /** Raw JSON arguments (validated by the tools module before invocation). */
+    arguments: unknown;
+}
+/** A complete (non-streaming) model response. */
+interface GenerateResponse {
+    /** Final answer text. */
+    text: string;
+    /** Reasoning/thinking content — only present for reasoning-capable models. (FR-003a) */
+    reasoning?: string;
+    /** Tool calls the model wants to make, if any. */
+    toolCalls?: ToolCall[];
+    /** Approximate token usage if reported by the provider. */
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+    };
+}
+/** An incremental streaming chunk. */
+type GenerateChunk = {
+    type: "text";
+    text: string;
+} | {
+    type: "reasoning";
+    text: string;
+} | {
+    type: "tool-call";
+    toolCall: ToolCall;
+} | {
+    type: "done";
+    response: GenerateResponse;
+};
+/**
+ * An LLM backend. Implementations adapt a concrete API (Copilot, OpenAI-compatible)
+ * onto this uniform surface.
+ */
+interface Provider {
+    /** Stable provider identifier, e.g. `"openai-compatible"`. */
+    readonly name: string;
+    /** Per-model capability configuration supplied by the caller. (FR-007a) */
+    readonly capabilities: ModelCapabilities;
+    /** Generate a complete response. */
+    generate(req: GenerateRequest): Promise<GenerateResponse>;
+    /** Generate a streamed response. */
+    generateStream(req: GenerateRequest): AsyncIterable<GenerateChunk>;
+}
+
+export type { CredentialSource as C, GenerateChunk as G, Provider as P, ToolCall as T, GenerateRequest as a, GenerateResponse as b, ToolSpec as c };

package/dist/provider-osAtfZ7x.d.ts

@@ -0,0 +1,82 @@
+import { a as ModelCapabilities, M as Message } from './types-Cn1g9Tg4.js';
+
+/**
+ * LLM provider abstraction. Agents and workflows depend only on this interface,
+ * never on a concrete provider, so new providers can be added without changing
+ * agent/workflow code. (FR-007)
+ *
+ * Credentials are always obtained via a caller-supplied callback and are never
+ * bundled, persisted, or logged by the framework. (FR-005a, FR-008)
+ *
+ * @packageDocumentation
+ */
+
+/** A caller-supplied source of credentials. The framework never stores the value. */
+interface CredentialSource {
+    /** Return the current credential (token/api key). May be async. */
+    getCredential(): string | Promise<string>;
+}
+/** A tool description passed to the provider so the model can decide to call it. */
+interface ToolSpec {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+/** A request to generate a model response. */
+interface GenerateRequest {
+    messages: Message[];
+    tools?: ToolSpec[];
+    /** Abort signal to cancel an in-flight request. */
+    signal?: AbortSignal;
+}
+/** A tool call requested by the model. */
+interface ToolCall {
+    id: string;
+    name: string;
+    /** Raw JSON arguments (validated by the tools module before invocation). */
+    arguments: unknown;
+}
+/** A complete (non-streaming) model response. */
+interface GenerateResponse {
+    /** Final answer text. */
+    text: string;
+    /** Reasoning/thinking content — only present for reasoning-capable models. (FR-003a) */
+    reasoning?: string;
+    /** Tool calls the model wants to make, if any. */
+    toolCalls?: ToolCall[];
+    /** Approximate token usage if reported by the provider. */
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+    };
+}
+/** An incremental streaming chunk. */
+type GenerateChunk = {
+    type: "text";
+    text: string;
+} | {
+    type: "reasoning";
+    text: string;
+} | {
+    type: "tool-call";
+    toolCall: ToolCall;
+} | {
+    type: "done";
+    response: GenerateResponse;
+};
+/**
+ * An LLM backend. Implementations adapt a concrete API (Copilot, OpenAI-compatible)
+ * onto this uniform surface.
+ */
+interface Provider {
+    /** Stable provider identifier, e.g. `"openai-compatible"`. */
+    readonly name: string;
+    /** Per-model capability configuration supplied by the caller. (FR-007a) */
+    readonly capabilities: ModelCapabilities;
+    /** Generate a complete response. */
+    generate(req: GenerateRequest): Promise<GenerateResponse>;
+    /** Generate a streamed response. */
+    generateStream(req: GenerateRequest): AsyncIterable<GenerateChunk>;
+}
+
+export type { CredentialSource as C, GenerateChunk as G, Provider as P, ToolCall as T, GenerateRequest as a, GenerateResponse as b, ToolSpec as c };

package/dist/providers/index.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+var chunkTLACSVEZ_cjs = require('../chunk-TLACSVEZ.cjs');
+require('../chunk-MQ2XTH3S.cjs');
+require('../chunk-IJASUMIQ.cjs');
+
+
+
+Object.defineProperty(exports, "createCopilotProvider", {
+  enumerable: true,
+  get: function () { return chunkTLACSVEZ_cjs.createCopilotProvider; }
+});
+Object.defineProperty(exports, "createOpenAICompatibleProvider", {
+  enumerable: true,
+  get: function () { return chunkTLACSVEZ_cjs.createOpenAICompatibleProvider; }
+});
+Object.defineProperty(exports, "providerErrorFromStatus", {
+  enumerable: true,
+  get: function () { return chunkTLACSVEZ_cjs.providerErrorFromStatus; }
+});
+Object.defineProperty(exports, "withRetry", {
+  enumerable: true,
+  get: function () { return chunkTLACSVEZ_cjs.withRetry; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/providers/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/providers/index.d.cts

@@ -0,0 +1,107 @@
+import { C as CredentialSource, P as Provider } from '../provider-CMAymr1b.cjs';
+export { G as GenerateChunk, a as GenerateRequest, b as GenerateResponse, T as ToolCall, c as ToolSpec } from '../provider-CMAymr1b.cjs';
+import { P as ProviderError } from '../errors-CjVz4W_5.cjs';
+import { a as ModelCapabilities } from '../types-Cn1g9Tg4.cjs';
+
+/**
+ * Exponential-backoff retry for transient provider failures. Transient errors
+ * (429 with Retry-After, 5xx, network/timeout) are retried; auth/4xx fail fast.
+ * (FR-008a)
+ *
+ * @packageDocumentation
+ */
+
+/** Retry tuning. All fields have safe defaults. */
+interface RetryOptions {
+    /** Maximum retry attempts after the first try. Default 3. */
+    maxRetries?: number;
+    /** Base delay in ms for backoff. Default 250. */
+    baseDelayMs?: number;
+    /** Maximum delay cap in ms. Default 8000. */
+    maxDelayMs?: number;
+}
+/**
+ * Run `fn`, retrying transient {@link ProviderError}s with exponential backoff
+ * and jitter. Non-transient errors are rethrown immediately (fail fast).
+ *
+ * @param fn - The operation to attempt. It should throw a {@link ProviderError}.
+ * @param opts - Retry tuning.
+ * @param retryAfterMs - Optional hook returning a server-specified delay (Retry-After).
+ */
+declare function withRetry<T>(fn: () => Promise<T>, opts?: RetryOptions, retryAfterMs?: (err: ProviderError) => number | undefined): Promise<T>;
+/** Map an HTTP status to a {@link ProviderError} with the right retry semantics. */
+declare function providerErrorFromStatus(status: number, message: string): ProviderError;
+
+/**
+ * OpenAI-compatible provider. Targets any endpoint speaking the OpenAI
+ * `/chat/completions` API, including local servers such as LM Studio via a custom
+ * `baseUrl`. (FR-006)
+ *
+ * @packageDocumentation
+ */
+
+/** Options for {@link createOpenAICompatibleProvider}. */
+interface OpenAICompatibleProviderOptions extends CredentialSource {
+    /** Base URL of the OpenAI-compatible API, e.g. `http://localhost:1234/v1`. */
+    baseUrl: string;
+    /** Per-model capability configuration. */
+    capabilities: ModelCapabilities;
+    /** Retry tuning for transient failures. */
+    retry?: RetryOptions;
+    /** Optional custom fetch (for testing or non-standard runtimes). */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Create an OpenAI-compatible provider (works with LM Studio, vLLM, etc.).
+ *
+ * @example
+ * ```ts
+ * const provider = createOpenAICompatibleProvider({
+ *   baseUrl: "http://localhost:1234/v1",
+ *   getCredential: () => process.env.LMSTUDIO_KEY ?? "",
+ *   capabilities: { model: "local", maxInputTokens: 262144, maxOutputTokens: 32000 },
+ * });
+ * ```
+ */
+declare function createOpenAICompatibleProvider(options: OpenAICompatibleProviderOptions): Provider;
+
+/**
+ * GitHub Copilot provider. (FR-005)
+ *
+ * Copilot's chat API is OpenAI-compatible, so this provider configures the shared
+ * OpenAI-compatible transport with Copilot's endpoint and the caller-supplied
+ * credential (a Copilot/GitHub token). The token is obtained via callback and is
+ * never bundled, persisted, or logged. (FR-005a)
+ *
+ * In a frontend-only deployment the end user supplies their own token (it stays
+ * client-side); in a backend deployment the developer may supply it, or the user
+ * sends it per request over SSL/TLS and the backend must not log or persist it.
+ *
+ * @packageDocumentation
+ */
+
+/** Options for {@link createCopilotProvider}. */
+interface CopilotProviderOptions extends CredentialSource {
+    /** Per-model capability configuration. */
+    capabilities: ModelCapabilities;
+    /** Override the Copilot base URL if needed. */
+    baseUrl?: string;
+    /** Retry tuning for transient failures. */
+    retry?: RetryOptions;
+    /** Optional custom fetch (for testing or non-standard runtimes). */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Create a GitHub Copilot provider.
+ *
+ * @example
+ * ```ts
+ * const provider = createCopilotProvider({
+ *   getCredential: () => myCopilotToken, // never logged or persisted
+ *   capabilities: { model: "gpt-4o", maxInputTokens: 128000, maxOutputTokens: 16000 },
+ * });
+ * ```
+ */
+declare function createCopilotProvider(options: CopilotProviderOptions): Provider;
+
+export { type CopilotProviderOptions, CredentialSource, type OpenAICompatibleProviderOptions, Provider, type RetryOptions, createCopilotProvider, createOpenAICompatibleProvider, providerErrorFromStatus, withRetry };

package/dist/providers/index.d.ts

@@ -0,0 +1,107 @@
+import { C as CredentialSource, P as Provider } from '../provider-osAtfZ7x.js';
+export { G as GenerateChunk, a as GenerateRequest, b as GenerateResponse, T as ToolCall, c as ToolSpec } from '../provider-osAtfZ7x.js';
+import { P as ProviderError } from '../errors-CjVz4W_5.js';
+import { a as ModelCapabilities } from '../types-Cn1g9Tg4.js';
+
+/**
+ * Exponential-backoff retry for transient provider failures. Transient errors
+ * (429 with Retry-After, 5xx, network/timeout) are retried; auth/4xx fail fast.
+ * (FR-008a)
+ *
+ * @packageDocumentation
+ */
+
+/** Retry tuning. All fields have safe defaults. */
+interface RetryOptions {
+    /** Maximum retry attempts after the first try. Default 3. */
+    maxRetries?: number;
+    /** Base delay in ms for backoff. Default 250. */
+    baseDelayMs?: number;
+    /** Maximum delay cap in ms. Default 8000. */
+    maxDelayMs?: number;
+}
+/**
+ * Run `fn`, retrying transient {@link ProviderError}s with exponential backoff
+ * and jitter. Non-transient errors are rethrown immediately (fail fast).
+ *
+ * @param fn - The operation to attempt. It should throw a {@link ProviderError}.
+ * @param opts - Retry tuning.
+ * @param retryAfterMs - Optional hook returning a server-specified delay (Retry-After).
+ */
+declare function withRetry<T>(fn: () => Promise<T>, opts?: RetryOptions, retryAfterMs?: (err: ProviderError) => number | undefined): Promise<T>;
+/** Map an HTTP status to a {@link ProviderError} with the right retry semantics. */
+declare function providerErrorFromStatus(status: number, message: string): ProviderError;
+
+/**
+ * OpenAI-compatible provider. Targets any endpoint speaking the OpenAI
+ * `/chat/completions` API, including local servers such as LM Studio via a custom
+ * `baseUrl`. (FR-006)
+ *
+ * @packageDocumentation
+ */
+
+/** Options for {@link createOpenAICompatibleProvider}. */
+interface OpenAICompatibleProviderOptions extends CredentialSource {
+    /** Base URL of the OpenAI-compatible API, e.g. `http://localhost:1234/v1`. */
+    baseUrl: string;
+    /** Per-model capability configuration. */
+    capabilities: ModelCapabilities;
+    /** Retry tuning for transient failures. */
+    retry?: RetryOptions;
+    /** Optional custom fetch (for testing or non-standard runtimes). */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Create an OpenAI-compatible provider (works with LM Studio, vLLM, etc.).
+ *
+ * @example
+ * ```ts
+ * const provider = createOpenAICompatibleProvider({
+ *   baseUrl: "http://localhost:1234/v1",
+ *   getCredential: () => process.env.LMSTUDIO_KEY ?? "",
+ *   capabilities: { model: "local", maxInputTokens: 262144, maxOutputTokens: 32000 },
+ * });
+ * ```
+ */
+declare function createOpenAICompatibleProvider(options: OpenAICompatibleProviderOptions): Provider;
+
+/**
+ * GitHub Copilot provider. (FR-005)
+ *
+ * Copilot's chat API is OpenAI-compatible, so this provider configures the shared
+ * OpenAI-compatible transport with Copilot's endpoint and the caller-supplied
+ * credential (a Copilot/GitHub token). The token is obtained via callback and is
+ * never bundled, persisted, or logged. (FR-005a)
+ *
+ * In a frontend-only deployment the end user supplies their own token (it stays
+ * client-side); in a backend deployment the developer may supply it, or the user
+ * sends it per request over SSL/TLS and the backend must not log or persist it.
+ *
+ * @packageDocumentation
+ */
+
+/** Options for {@link createCopilotProvider}. */
+interface CopilotProviderOptions extends CredentialSource {
+    /** Per-model capability configuration. */
+    capabilities: ModelCapabilities;
+    /** Override the Copilot base URL if needed. */
+    baseUrl?: string;
+    /** Retry tuning for transient failures. */
+    retry?: RetryOptions;
+    /** Optional custom fetch (for testing or non-standard runtimes). */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Create a GitHub Copilot provider.
+ *
+ * @example
+ * ```ts
+ * const provider = createCopilotProvider({
+ *   getCredential: () => myCopilotToken, // never logged or persisted
+ *   capabilities: { model: "gpt-4o", maxInputTokens: 128000, maxOutputTokens: 16000 },
+ * });
+ * ```
+ */
+declare function createCopilotProvider(options: CopilotProviderOptions): Provider;
+
+export { type CopilotProviderOptions, CredentialSource, type OpenAICompatibleProviderOptions, Provider, type RetryOptions, createCopilotProvider, createOpenAICompatibleProvider, providerErrorFromStatus, withRetry };

package/dist/providers/index.js

@@ -0,0 +1,5 @@
+export { createCopilotProvider, createOpenAICompatibleProvider, providerErrorFromStatus, withRetry } from '../chunk-UVWQWOLO.js';
+import '../chunk-IXV4UIF5.js';
+import '../chunk-DEABART4.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/providers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/registry-CpO0yH5v.d.ts

@@ -0,0 +1,57 @@
+import { T as Tool } from './tool-CSCC87OD.js';
+import { c as ToolSpec } from './provider-osAtfZ7x.js';
+import { T as ToolError } from './errors-CjVz4W_5.js';
+
+/**
+ * Tool registry: registration, namespacing, granular enable/disable, and
+ * validated invocation. Tools are addressed namespaced by source (`server.tool`)
+ * so collisions across MCP servers and local code are impossible. (FR-012a, FR-014a)
+ *
+ * @packageDocumentation
+ */
+
+/** Result of invoking a tool. */
+interface ToolResult {
+    /** The tool's (namespaced) name. */
+    name: string;
+    /** The returned value on success. */
+    value?: unknown;
+    /** A typed error on failure (fed back to the model for self-correction). */
+    error?: ToolError;
+}
+/** Compute the namespaced address for a tool. */
+declare function namespacedName(tool: Pick<Tool, "name" | "source">): string;
+/** A registry of tools available to an agent. */
+declare class ToolRegistry {
+    private readonly tools;
+    private readonly disabled;
+    private readonly disabledServers;
+    constructor(tools?: Tool[]);
+    /** Register a tool under its namespaced name. */
+    register(tool: Tool): void;
+    /** Enable a tool by namespaced name. */
+    enable(name: string): void;
+    /** Disable a single tool by namespaced name. (FR-012a) */
+    disable(name: string): void;
+    /** Disable every tool from an MCP server id. (FR-012a) */
+    disableServer(serverId: string): void;
+    /** Re-enable every tool from an MCP server id. */
+    enableServer(serverId: string): void;
+    private isEnabled;
+    /** List currently enabled tools (those presented to the agent). */
+    list(): Tool[];
+    /** Provider-facing specs for enabled tools. */
+    specs(): ToolSpec[];
+    /**
+     * Validate and invoke a tool. Never throws for tool-level failures; instead
+     * returns a {@link ToolResult} with a typed error so the agent can self-correct.
+     * (FR-011a, FR-012, FR-012c)
+     *
+     * @param name - Namespaced tool name.
+     * @param args - Raw arguments from the model.
+     * @param timeoutMs - Optional per-call timeout.
+     */
+    invoke(name: string, args: unknown, timeoutMs?: number): Promise<ToolResult>;
+}
+
+export { ToolRegistry as T, type ToolResult as a, namespacedName as n };

package/dist/registry-D4fThGiN.d.cts

@@ -0,0 +1,57 @@
+import { T as Tool } from './tool-BZg_znMZ.cjs';
+import { c as ToolSpec } from './provider-CMAymr1b.cjs';
+import { T as ToolError } from './errors-CjVz4W_5.cjs';
+
+/**
+ * Tool registry: registration, namespacing, granular enable/disable, and
+ * validated invocation. Tools are addressed namespaced by source (`server.tool`)
+ * so collisions across MCP servers and local code are impossible. (FR-012a, FR-014a)
+ *
+ * @packageDocumentation
+ */
+
+/** Result of invoking a tool. */
+interface ToolResult {
+    /** The tool's (namespaced) name. */
+    name: string;
+    /** The returned value on success. */
+    value?: unknown;
+    /** A typed error on failure (fed back to the model for self-correction). */
+    error?: ToolError;
+}
+/** Compute the namespaced address for a tool. */
+declare function namespacedName(tool: Pick<Tool, "name" | "source">): string;
+/** A registry of tools available to an agent. */
+declare class ToolRegistry {
+    private readonly tools;
+    private readonly disabled;
+    private readonly disabledServers;
+    constructor(tools?: Tool[]);
+    /** Register a tool under its namespaced name. */
+    register(tool: Tool): void;
+    /** Enable a tool by namespaced name. */
+    enable(name: string): void;
+    /** Disable a single tool by namespaced name. (FR-012a) */
+    disable(name: string): void;
+    /** Disable every tool from an MCP server id. (FR-012a) */
+    disableServer(serverId: string): void;
+    /** Re-enable every tool from an MCP server id. */
+    enableServer(serverId: string): void;
+    private isEnabled;
+    /** List currently enabled tools (those presented to the agent). */
+    list(): Tool[];
+    /** Provider-facing specs for enabled tools. */
+    specs(): ToolSpec[];
+    /**
+     * Validate and invoke a tool. Never throws for tool-level failures; instead
+     * returns a {@link ToolResult} with a typed error so the agent can self-correct.
+     * (FR-011a, FR-012, FR-012c)
+     *
+     * @param name - Namespaced tool name.
+     * @param args - Raw arguments from the model.
+     * @param timeoutMs - Optional per-call timeout.
+     */
+    invoke(name: string, args: unknown, timeoutMs?: number): Promise<ToolResult>;
+}
+
+export { ToolRegistry as T, type ToolResult as a, namespacedName as n };

package/dist/skill-DfNChtJN.d.cts

@@ -0,0 +1,45 @@
+/**
+ * Skills: domain-specific knowledge bundles attached to agents. Skills use
+ * progressive disclosure — only a skill's short description is used to decide
+ * relevance, and its full content is loaded only when the skill is deemed needed.
+ * (FR-016, FR-017)
+ *
+ * @packageDocumentation
+ */
+/** A source of skill content, loaded on demand. */
+type SkillSource = {
+    kind: "inline";
+    content: string;
+} | {
+    kind: "file";
+    path: string;
+} | {
+    kind: "code";
+    load: () => Promise<string>;
+};
+/** A domain knowledge bundle. */
+interface Skill {
+    /** Unique skill name. */
+    name: string;
+    /** Short description — the ONLY text used to decide relevance. (FR-017) */
+    description: string;
+    /** Content sources, read only when the skill is selected. */
+    sources: SkillSource[];
+}
+/**
+ * Define a skill.
+ *
+ * @example
+ * ```ts
+ * const refund = defineSkill({
+ *   name: "refund-policy",
+ *   description: "Company refund and return rules.",
+ *   sources: [{ kind: "inline", content: "Refunds allowed within 30 days..." }],
+ * });
+ * ```
+ */
+declare function defineSkill(skill: Skill): Skill;
+/** Read a single source's content. File sources require a Node runtime. */
+declare function loadSource(source: SkillSource): Promise<string>;
+
+export { type Skill as S, type SkillSource as a, defineSkill as d, loadSource as l };

package/dist/skill-DfNChtJN.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Skills: domain-specific knowledge bundles attached to agents. Skills use
+ * progressive disclosure — only a skill's short description is used to decide
+ * relevance, and its full content is loaded only when the skill is deemed needed.
+ * (FR-016, FR-017)
+ *
+ * @packageDocumentation
+ */
+/** A source of skill content, loaded on demand. */
+type SkillSource = {
+    kind: "inline";
+    content: string;
+} | {
+    kind: "file";
+    path: string;
+} | {
+    kind: "code";
+    load: () => Promise<string>;
+};
+/** A domain knowledge bundle. */
+interface Skill {
+    /** Unique skill name. */
+    name: string;
+    /** Short description — the ONLY text used to decide relevance. (FR-017) */
+    description: string;
+    /** Content sources, read only when the skill is selected. */
+    sources: SkillSource[];
+}
+/**
+ * Define a skill.
+ *
+ * @example
+ * ```ts
+ * const refund = defineSkill({
+ *   name: "refund-policy",
+ *   description: "Company refund and return rules.",
+ *   sources: [{ kind: "inline", content: "Refunds allowed within 30 days..." }],
+ * });
+ * ```
+ */
+declare function defineSkill(skill: Skill): Skill;
+/** Read a single source's content. File sources require a Node runtime. */
+declare function loadSource(source: SkillSource): Promise<string>;
+
+export { type Skill as S, type SkillSource as a, defineSkill as d, loadSource as l };

package/dist/skills/index.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var chunkWSMYH2IN_cjs = require('../chunk-WSMYH2IN.cjs');
+
+
+
+Object.defineProperty(exports, "SkillIndex", {
+  enumerable: true,
+  get: function () { return chunkWSMYH2IN_cjs.SkillIndex; }
+});
+Object.defineProperty(exports, "defineSkill", {
+  enumerable: true,
+  get: function () { return chunkWSMYH2IN_cjs.defineSkill; }
+});
+Object.defineProperty(exports, "loadSource", {
+  enumerable: true,
+  get: function () { return chunkWSMYH2IN_cjs.loadSource; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/skills/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/skills/index.d.cts

@@ -0,0 +1,30 @@
+import { S as Skill } from '../skill-DfNChtJN.cjs';
+export { a as SkillSource, d as defineSkill, l as loadSource } from '../skill-DfNChtJN.cjs';
+
+/**
+ * Client-side keyword/text index over skill descriptions. No embeddings and no
+ * extra provider — relevance is decided by simple token overlap so it runs fully
+ * in the browser/edge. Full content is loaded only after a skill is selected.
+ * (FR-017, FR-017a)
+ *
+ * @packageDocumentation
+ */
+
+/** Indexes skills by description and selects relevant ones for a prompt. */
+declare class SkillIndex {
+    private readonly entries;
+    constructor(skills?: Skill[]);
+    /** Add a skill to the index (description-only). */
+    add(skill: Skill): void;
+    /**
+     * Select skills relevant to `prompt` by keyword overlap with their descriptions.
+     *
+     * @param prompt - The user prompt.
+     * @param minOverlap - Minimum overlapping tokens to count as relevant. Default 1.
+     */
+    select(prompt: string, minOverlap?: number): Skill[];
+    /** Load the full content of a selected skill (concatenated sources). (FR-017) */
+    load(skill: Skill): Promise<string>;
+}
+
+export { Skill, SkillIndex };