agentfootprint 7.12.0 → 7.14.0

package/dist/esm/hosting/types.d.ts

@@ -0,0 +1,206 @@
+/**
+ * hosting/types — the two ports an agent needs to stand up and stay up.
+ *
+ * `AgentHost` is "something can call me". `SessionLifecycle` is "the
+ * conversation outlives the request". Both are deliberately written in the
+ * vocabulary every transport and every store already has — an input, a reply,
+ * a session id, a stored blob — and in nothing else.
+ *
+ * **The rule these types are written under:** no runtime, product or protocol
+ * gets a field, a name or an assumption here. A port shaped around one
+ * provider's request envelope stops being a port and becomes that provider's
+ * SDK with extra steps, and every later adapter pays for it. If a decision only
+ * makes sense for one place you might deploy, it belongs in the adapter for
+ * that place, not in this file. `nodeHost` is the first adapter and it does not
+ * get special treatment either: its paths, its status codes and its JSON body
+ * shape all live in `nodeHost.ts`, and nothing in this file knows they exist.
+ *
+ * Pattern: Ports & adapters (hexagonal). Role: the port side, exclusively.
+ */
+import type { Agent } from '../core/Agent.js';
+import type { AgentRunCheckpoint } from '../core/runCheckpoint.js';
+/**
+ * Something a host can do BEYOND the baseline of "accept a request, deliver one
+ * reply". Read it from {@link AgentHost.capabilities} and branch on it — never
+ * assume it, and never infer it from the adapter's name.
+ *
+ * The union starts at exactly what a shipped adapter can honour today. A name
+ * is added when an adapter can actually keep the promise, never in anticipation
+ * of a transport that does not exist yet: a capability nobody implements is a
+ * promise the library cannot keep, and pre-minting one for an imagined future
+ * transport would bake that transport's assumptions in before it arrives.
+ */
+export type HostCapability = 'streaming';
+/**
+ * One inbound request, as the transport described it.
+ */
+export interface HostRequest {
+    /** What the caller is asking. */
+    readonly input: string;
+    /**
+     * The conversation this request CLAIMS to belong to — caller data, exactly as
+     * the transport declared it (a JSON field, a header, a path segment).
+     *
+     * It is **not identity** and must never be trusted as identity on its own:
+     * anyone who can reach the host can put any string here, including someone
+     * else's. Authenticate the caller by your own means, then check that the
+     * authenticated principal is allowed this session, before you serve it.
+     */
+    readonly sessionId?: string;
+    /**
+     * Transport headers with lower-cased names, as delivered. Present so a
+     * handler can map its own conventions (a correlation id, a tenant) without
+     * the port having to guess which ones matter.
+     */
+    readonly headers?: Readonly<Record<string, string>>;
+    /** Aborted when the caller goes away. */
+    readonly signal?: AbortSignal;
+}
+/**
+ * The one reply a request gets. Exactly one of {@link HostReply.complete} or
+ * {@link HostReply.fail} ends it; a second call is ignored rather than allowed
+ * to corrupt the wire.
+ */
+export interface HostReply {
+    /** Deliver the final answer and end the reply. */
+    complete(output: string): void;
+    /**
+     * A piece of the answer, as it is produced.
+     *
+     * Optional on the TYPE so a minimal adapter need not implement it — every
+     * shipped adapter does. Whether the caller SEES the pieces as they arrive is
+     * the whole difference between hosts, and that is what `'streaming'` in
+     * {@link AgentHost.capabilities} reports. A host without it buffers what it is
+     * handed and the authoritative `complete(output)` is what the caller
+     * receives; the buffer is settled by the completion, never sent alongside it,
+     * because a chunk is a preview of the same text and delivering both would
+     * hand the caller the answer twice.
+     *
+     * Handler code is identical either way: emit freely, complete once.
+     */
+    emit?(chunk: string): void;
+    /** End the reply with a failure. */
+    fail(error: Error): void;
+}
+/**
+ * What you hand {@link AgentHost.serve}. Throwing is treated exactly like
+ * calling `reply.fail(err)` — a handler that throws is a failed request, never
+ * a hung one.
+ */
+export type HostHandler = (request: HostRequest, reply: HostReply) => void | Promise<void>;
+/** A live host. */
+export interface HostHandle {
+    /**
+     * Stop taking new requests, let the in-flight ones finish, then release the
+     * transport. Idempotent, so a shutdown hook and an explicit close can
+     * coexist. Requests arriving after it are refused with a
+     * {@link HostClosedError} naming the adapter.
+     */
+    close(): Promise<void>;
+}
+/**
+ * The port: something that can carry requests to one handler and carry its
+ * replies back.
+ */
+export interface AgentHost {
+    /**
+     * Which adapter this is. Every refusal names it, so an error tells you WHO
+     * refused rather than leaving you to guess which layer you are looking at.
+     */
+    readonly name: string;
+    /** What this adapter can do beyond the baseline. Feature-detect; never assume. */
+    readonly capabilities: readonly HostCapability[];
+    /** Start serving. Resolves once the host is actually live. */
+    serve(handler: HostHandler): Promise<HostHandle>;
+}
+/**
+ * A conversation packed for storage.
+ *
+ * `format` names WHAT is inside, so a reader that does not know the shape
+ * refuses BY NAME instead of restoring a conversation it cannot actually read.
+ * Formats are ADDED, never redefined: an old runtime meeting a new format says
+ * so and stops, which is the only safe thing it can do with a payload it cannot
+ * interpret.
+ *
+ * `'conversation-v1'` stores a conversation and only a conversation. A run that
+ * paused mid-flow is a conversation PLUS an engine checkpoint, and this format
+ * has nowhere to put the second half — which is why `standingAgent` refuses to
+ * store a paused run rather than storing half of it. Carrying a pause would be
+ * a NEW format name in this same envelope, read by a runtime that knows it and
+ * refused by name everywhere else. That is what the version field is for.
+ */
+export interface CheckpointEnvelope {
+    /** Names the shape of `data`. Unknown values are refused, never guessed at. */
+    readonly format: 'conversation-v1';
+    /** The conversation itself — an `AgentRunCheckpoint` for `'conversation-v1'`. */
+    readonly data: AgentRunCheckpoint;
+    /** Wall-clock when it was packed. Diagnostic. */
+    readonly savedAt: number;
+}
+/**
+ * Why a session is being woken.
+ *
+ * One member, because one thing in this release can actually fire it: a request
+ * arrived for that session. Naming reasons nothing can produce would be an
+ * interface describing a system that does not exist.
+ */
+export type WakeReason = 'invoke';
+/**
+ * The port: where a conversation lives between requests.
+ *
+ * Deliberately two required methods. Anything a real store also wants — a TTL,
+ * a scan, a delete — is that store's own API, not a demand this port makes of
+ * every store that will ever implement it.
+ */
+export interface SessionLifecycle {
+    /** The stored conversation, or `undefined` for a session that has none yet. */
+    hydrate(sessionId: string): Promise<CheckpointEnvelope | undefined>;
+    /** Store the conversation for this session. Last write wins. */
+    persist(sessionId: string, envelope: CheckpointEnvelope): Promise<void>;
+    /**
+     * Called once per served request, before `hydrate`, for stores that need to
+     * spin something up before they can answer. Errors from it fail the request —
+     * a store that could not wake cannot be read from either.
+     */
+    onWake?(sessionId: string, reason: WakeReason): void | Promise<void>;
+}
+/**
+ * What to do when a request arrives for a session that already has a run in
+ * flight.
+ *
+ *  - `'reject'` (default) — refuse it, naming the run that is already going.
+ *    A user who double-submits gets one answer and one refusal, not two runs
+ *    racing to write the same conversation.
+ *  - `'enqueue'` — queue it. It starts after the active run has persisted, so
+ *    the second turn sees the first turn's stored state rather than the state
+ *    it was about to overwrite.
+ *
+ * This governs the SAME session only. A request for a different session is
+ * never refused — there is nothing wrong with it; it simply waits its turn.
+ */
+export type ConcurrentInvokePolicy = 'reject' | 'enqueue';
+/**
+ * Options for {@link standingAgent}.
+ *
+ * Generic in the host's own handle type so composing does not cost you what
+ * the adapter told you. `nodeHost` hands back the URL it actually bound —
+ * which is the only way to find out when you asked for port `0` — and passing
+ * it through `standingAgent` keeps that, without the port having to know that
+ * "a URL" is a thing some adapters have.
+ */
+export interface StandingAgentOptions<TH extends HostHandle = HostHandle> {
+    /**
+     * The agent that answers. ONE instance, shared by every session — which is
+     * why the composer runs one request at a time (see
+     * {@link ConcurrentInvokePolicy}).
+     */
+    readonly agent: Agent;
+    /** Where conversations live between requests. */
+    readonly sessions: SessionLifecycle;
+    /** What carries requests in. */
+    readonly host: AgentHost & {
+        serve(handler: HostHandler): Promise<TH>;
+    };
+    /** Default `'reject'`. See {@link ConcurrentInvokePolicy}. */
+    readonly onConcurrentInvoke?: ConcurrentInvokePolicy;
+}

package/dist/esm/hosting/types.js

@@ -0,0 +1,21 @@
+/**
+ * hosting/types — the two ports an agent needs to stand up and stay up.
+ *
+ * `AgentHost` is "something can call me". `SessionLifecycle` is "the
+ * conversation outlives the request". Both are deliberately written in the
+ * vocabulary every transport and every store already has — an input, a reply,
+ * a session id, a stored blob — and in nothing else.
+ *
+ * **The rule these types are written under:** no runtime, product or protocol
+ * gets a field, a name or an assumption here. A port shaped around one
+ * provider's request envelope stops being a port and becomes that provider's
+ * SDK with extra steps, and every later adapter pays for it. If a decision only
+ * makes sense for one place you might deploy, it belongs in the adapter for
+ * that place, not in this file. `nodeHost` is the first adapter and it does not
+ * get special treatment either: its paths, its status codes and its JSON body
+ * shape all live in `nodeHost.ts`, and nothing in this file knows they exist.
+ *
+ * Pattern: Ports & adapters (hexagonal). Role: the port side, exclusively.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/esm/hosting/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/hosting/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG"}

package/dist/esm/lib/injection-engine/index.d.ts

@@ -13,6 +13,7 @@ export { defineInstruction, type DefineInstructionOptions } from './factories/de
 export { defineRelevanceHint, type RelevanceHintOptions } from './factories/defineRelevanceHint.js';
 export { defineSkill, resolveSurfaceMode, type DefineSkillOptions, type SurfaceMode, type RefreshPolicy, type AutoActivateMode, } from './factories/defineSkill.js';
 export { SkillRegistry, type SkillRegistryOptions } from './SkillRegistry.js';
+export { skillsFromDir, type SkillsFromDirOptions } from './skillsFromDir.js';
 export { buildListSkillsTool, buildReadSkillTool, type SkillToolPair } from './skillTools.js';
 export { defineSteering, type DefineSteeringOptions } from './factories/defineSteering.js';
 export { defineFact, type DefineFactOptions } from './factories/defineFact.js';

package/dist/esm/lib/injection-engine/index.js

@@ -15,6 +15,10 @@ export { defineInstruction } from './factories/defineInstruction.js';
 export { defineRelevanceHint } from './factories/defineRelevanceHint.js';
 export { defineSkill, resolveSurfaceMode, } from './factories/defineSkill.js';
 export { SkillRegistry } from './SkillRegistry.js';
+// File-authored skills — a loader over `defineSkill`, not a second mechanism.
+// Node-only (reads the filesystem); node:fs is imported lazily inside the call
+// so this barrel stays safe to import from a browser bundle.
+export { skillsFromDir } from './skillsFromDir.js';
 // Skill-tool builders — used by SkillRegistry.toTools() and the Agent's
 // auto-attach path. Exported so consumers building custom tool wiring
 // (e.g., gatedTools chains) can compose the same `list_skills` /

package/dist/esm/lib/injection-engine/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/lib/injection-engine/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAYH,+DAA+D;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEpD,SAAS;AACT,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EACL,2BAA2B,GAE5B,MAAM,kCAAkC,CAAC;AAE1C,gFAAgF;AAChF,OAAO,EAAE,iBAAiB,EAAiC,MAAM,kCAAkC,CAAC;AACpG,OAAO,EAAE,mBAAmB,EAA6B,MAAM,oCAAoC,CAAC;AAEpG,OAAO,EACL,WAAW,EACX,kBAAkB,GAKnB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,aAAa,EAA6B,MAAM,oBAAoB,CAAC;AAE9E,wEAAwE;AACxE,sEAAsE;AACtE,iEAAiE;AACjE,+BAA+B;AAC/B,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAsB,MAAM,iBAAiB,CAAC;AAE9F,OAAO,EAAE,cAAc,EAA8B,MAAM,+BAA+B,CAAC;AAE3F,OAAO,EAAE,UAAU,EAA0B,MAAM,2BAA2B,CAAC;AAE/E,6EAA6E;AAC7E,0EAA0E;AAC1E,qDAAqD;AACrD,OAAO,EACL,eAAe,GAGhB,MAAM,gCAAgC,CAAC;AAExC,4EAA4E;AAC5E,8EAA8E;AAC9E,OAAO,EACL,UAAU,EACV,WAAW,EACX,wBAAwB,GAoBzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,aAAa,EACb,eAAe,EACf,WAAW,GAIZ,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/lib/injection-engine/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAYH,+DAA+D;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEpD,SAAS;AACT,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EACL,2BAA2B,GAE5B,MAAM,kCAAkC,CAAC;AAE1C,gFAAgF;AAChF,OAAO,EAAE,iBAAiB,EAAiC,MAAM,kCAAkC,CAAC;AACpG,OAAO,EAAE,mBAAmB,EAA6B,MAAM,oCAAoC,CAAC;AAEpG,OAAO,EACL,WAAW,EACX,kBAAkB,GAKnB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,aAAa,EAA6B,MAAM,oBAAoB,CAAC;AAE9E,8EAA8E;AAC9E,+EAA+E;AAC/E,6DAA6D;AAC7D,OAAO,EAAE,aAAa,EAA6B,MAAM,oBAAoB,CAAC;AAE9E,wEAAwE;AACxE,sEAAsE;AACtE,iEAAiE;AACjE,+BAA+B;AAC/B,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAsB,MAAM,iBAAiB,CAAC;AAE9F,OAAO,EAAE,cAAc,EAA8B,MAAM,+BAA+B,CAAC;AAE3F,OAAO,EAAE,UAAU,EAA0B,MAAM,2BAA2B,CAAC;AAE/E,6EAA6E;AAC7E,0EAA0E;AAC1E,qDAAqD;AACrD,OAAO,EACL,eAAe,GAGhB,MAAM,gCAAgC,CAAC;AAExC,4EAA4E;AAC5E,8EAA8E;AAC9E,OAAO,EACL,UAAU,EACV,WAAW,EACX,wBAAwB,GAoBzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,aAAa,EACb,eAAe,EACf,WAAW,GAIZ,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/esm/lib/injection-engine/skillsFromDir.d.ts

@@ -0,0 +1,80 @@
+/**
+ * skillsFromDir — load Skills that were AUTHORED AS FILES.
+ *
+ * The just-in-time half of skills already ships: `defineSkill` produces an
+ * Injection whose `description` is all the model sees until it calls
+ * `read_skill(<id>)`, at which point the body enters the context. What did not
+ * ship was the other half — a way to keep those bodies where prose belongs, in
+ * files, next to the code they describe, reviewable in a diff.
+ *
+ * This is that loader, and nothing more. It reads a directory of `SKILL.md`
+ * files and hands each one to `defineSkill`. The progressive disclosure, the
+ * activation tool, the slot routing — all unchanged, all upstream of here.
+ *
+ *   skills/
+ *     billing/SKILL.md
+ *     refunds/SKILL.md
+ *
+ *   ---
+ *   name: billing
+ *   description: Use for refunds, charges and billing questions.
+ *   ---
+ *   When handling billing: confirm identity first, then …
+ *
+ *   const skills = await skillsFromDir('./skills');
+ *   const agent = Agent.create({ provider, model }).skills({ list: () => skills }).build();
+ *
+ * The frontmatter is the disclosure stub (`name` + `description` — what the
+ * model reads when deciding), and everything after the closing fence is the
+ * body (what it reads after deciding). That is the same file convention Claude
+ * Code made familiar, so a skill folder is portable between the two.
+ *
+ * ── Why authorship is decided here, at load time ─────────────────────────────
+ * A Skill body is *instructions to a model*. Where it came from is therefore a
+ * security property, not a convenience: content fetched at run time from
+ * somewhere else is content someone else can change after you reviewed it.
+ * This loader accepts a local directory and nothing else — a URL is refused BY
+ * NAME rather than fetched — because "these files are mine" is a claim you can
+ * only make about a path on your own disk at build time. Each file is read
+ * ONCE, here; a later edit does not reach a run already in flight.
+ *
+ * Node-only. `node:fs/promises` and `node:path` are imported lazily inside the
+ * call, the same gating `lib/tool-lint/cli.ts` uses: this module is reachable
+ * from the `agentfootprint/injection-engine` barrel, and a TOP-LEVEL node:fs
+ * import detonates a browser bundle at module-eval even when nothing calls it.
+ */
+import type { Injection } from './types.js';
+import { type SurfaceMode } from './factories/defineSkill.js';
+export interface SkillsFromDirOptions {
+    /**
+     * Override the activation tool name for every loaded skill. Defaults to
+     * `defineSkill`'s own default, `'read_skill'`.
+     */
+    readonly viaToolName?: string;
+    /**
+     * Where a loaded skill's body lands once activated. Defaults to
+     * `defineSkill`'s own default, `'auto'`. See {@link SurfaceMode}.
+     */
+    readonly surfaceMode?: SurfaceMode;
+}
+/**
+ * Load every `SKILL.md` under `dir` as a Skill Injection.
+ *
+ * Two layouts are accepted, and they can be mixed:
+ *   - `dir/<anything>/SKILL.md` — one folder per skill (the portable layout,
+ *     and the one to prefer: the folder can hold the skill's other assets).
+ *   - `dir/SKILL.md` — the directory IS one skill.
+ *
+ * The returned array is sorted by skill name, so a chart built from it is
+ * stable regardless of the order the filesystem happened to hand back.
+ *
+ * @param dir - A local filesystem path. A URL (or any `scheme://` string, or a
+ *   UNC network path) is refused by name — see the module header for why.
+ * @param opts - Applied uniformly to every loaded skill.
+ *
+ * @throws when `dir` is not a local path, does not exist, is not a directory,
+ *   or contains no `SKILL.md` at all; when a file's frontmatter is malformed
+ *   (the message names the file); or when two files claim the same skill name
+ *   (the message names both).
+ */
+export declare function skillsFromDir(dir: string, opts?: SkillsFromDirOptions): Promise<readonly Injection[]>;

package/dist/esm/lib/injection-engine/skillsFromDir.js

@@ -0,0 +1,243 @@
+/**
+ * skillsFromDir — load Skills that were AUTHORED AS FILES.
+ *
+ * The just-in-time half of skills already ships: `defineSkill` produces an
+ * Injection whose `description` is all the model sees until it calls
+ * `read_skill(<id>)`, at which point the body enters the context. What did not
+ * ship was the other half — a way to keep those bodies where prose belongs, in
+ * files, next to the code they describe, reviewable in a diff.
+ *
+ * This is that loader, and nothing more. It reads a directory of `SKILL.md`
+ * files and hands each one to `defineSkill`. The progressive disclosure, the
+ * activation tool, the slot routing — all unchanged, all upstream of here.
+ *
+ *   skills/
+ *     billing/SKILL.md
+ *     refunds/SKILL.md
+ *
+ *   ---
+ *   name: billing
+ *   description: Use for refunds, charges and billing questions.
+ *   ---
+ *   When handling billing: confirm identity first, then …
+ *
+ *   const skills = await skillsFromDir('./skills');
+ *   const agent = Agent.create({ provider, model }).skills({ list: () => skills }).build();
+ *
+ * The frontmatter is the disclosure stub (`name` + `description` — what the
+ * model reads when deciding), and everything after the closing fence is the
+ * body (what it reads after deciding). That is the same file convention Claude
+ * Code made familiar, so a skill folder is portable between the two.
+ *
+ * ── Why authorship is decided here, at load time ─────────────────────────────
+ * A Skill body is *instructions to a model*. Where it came from is therefore a
+ * security property, not a convenience: content fetched at run time from
+ * somewhere else is content someone else can change after you reviewed it.
+ * This loader accepts a local directory and nothing else — a URL is refused BY
+ * NAME rather than fetched — because "these files are mine" is a claim you can
+ * only make about a path on your own disk at build time. Each file is read
+ * ONCE, here; a later edit does not reach a run already in flight.
+ *
+ * Node-only. `node:fs/promises` and `node:path` are imported lazily inside the
+ * call, the same gating `lib/tool-lint/cli.ts` uses: this module is reachable
+ * from the `agentfootprint/injection-engine` barrel, and a TOP-LEVEL node:fs
+ * import detonates a browser bundle at module-eval even when nothing calls it.
+ */
+import { defineSkill } from './factories/defineSkill.js';
+/** The file name every skill folder is expected to use. */
+const SKILL_FILE = 'SKILL.md';
+/**
+ * Skill ids ride into `read_skill`'s `enum` and into the skill-graph's node
+ * ids. The house tool-name charset keeps them quotable in a prompt, comparable
+ * as plain strings, and safe as an object key.
+ */
+const SKILL_NAME_RE = /^[a-zA-Z0-9_-]{1,64}$/;
+/** Anything of the form `scheme://…` — http, https, s3, git+ssh, file, … */
+const URL_LIKE_RE = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//;
+/**
+ * Load every `SKILL.md` under `dir` as a Skill Injection.
+ *
+ * Two layouts are accepted, and they can be mixed:
+ *   - `dir/<anything>/SKILL.md` — one folder per skill (the portable layout,
+ *     and the one to prefer: the folder can hold the skill's other assets).
+ *   - `dir/SKILL.md` — the directory IS one skill.
+ *
+ * The returned array is sorted by skill name, so a chart built from it is
+ * stable regardless of the order the filesystem happened to hand back.
+ *
+ * @param dir - A local filesystem path. A URL (or any `scheme://` string, or a
+ *   UNC network path) is refused by name — see the module header for why.
+ * @param opts - Applied uniformly to every loaded skill.
+ *
+ * @throws when `dir` is not a local path, does not exist, is not a directory,
+ *   or contains no `SKILL.md` at all; when a file's frontmatter is malformed
+ *   (the message names the file); or when two files claim the same skill name
+ *   (the message names both).
+ */
+export async function skillsFromDir(dir, opts = {}) {
+    assertLocalDirectoryArgument(dir);
+    // Lazy node imports (browser-compat) — see module header.
+    const { readdir, readFile, stat } = await import('node:fs/promises');
+    const { join } = await import('node:path');
+    let isDirectory = false;
+    try {
+        isDirectory = (await stat(dir)).isDirectory();
+    }
+    catch {
+        throw new Error(`skillsFromDir: '${dir}' does not exist. Pass the directory that holds your ` +
+            `${SKILL_FILE} folders.`);
+    }
+    if (!isDirectory) {
+        throw new Error(`skillsFromDir: '${dir}' is a file, not a directory. Pass the directory that holds ` +
+            `your ${SKILL_FILE} folders.`);
+    }
+    const entries = await readdir(dir, { withFileTypes: true });
+    const files = [];
+    // `dir/SKILL.md` — the whole directory is one skill.
+    if (entries.some((e) => e.isFile() && e.name === SKILL_FILE)) {
+        files.push(join(dir, SKILL_FILE));
+    }
+    // `dir/<folder>/SKILL.md` — the portable layout.
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const candidate = join(dir, entry.name, SKILL_FILE);
+        try {
+            if ((await stat(candidate)).isFile())
+                files.push(candidate);
+        }
+        catch {
+            // A subdirectory without a SKILL.md is not an error — a skill folder can
+            // sit next to assets, fixtures, or anything else the author keeps here.
+        }
+    }
+    if (files.length === 0) {
+        throw new Error(`skillsFromDir: no ${SKILL_FILE} found under '${dir}'. Expected '${dir}/<skill>/${SKILL_FILE}' ` +
+            `or '${dir}/${SKILL_FILE}'.`);
+    }
+    const parsed = [];
+    for (const file of files.sort()) {
+        parsed.push(parseSkillFile(await readFile(file, 'utf8'), file));
+    }
+    // Collisions are refused naming BOTH files: with only the id in the message
+    // you would know a duplicate exists and still have to go find the pair.
+    const byName = new Map();
+    for (const skill of parsed) {
+        const clash = byName.get(skill.name);
+        if (clash) {
+            throw new Error(`skillsFromDir: two files claim the skill name '${skill.name}' — '${clash.file}' and ` +
+                `'${skill.file}'. Skill ids must be unique (read_skill dispatches by id); rename one.`);
+        }
+        byName.set(skill.name, skill);
+    }
+    return parsed
+        .slice()
+        .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
+        .map((skill) => defineSkill({
+        id: skill.name,
+        description: skill.description,
+        body: skill.body,
+        ...(opts.viaToolName !== undefined && { viaToolName: opts.viaToolName }),
+        ...(opts.surfaceMode !== undefined && { surfaceMode: opts.surfaceMode }),
+    }));
+}
+// ─── Authorship guard ──────────────────────────────────────────────
+/**
+ * Refuse anything that is not a local path, BY NAME. The message quotes what
+ * was passed, because the whole point is that the reader can see the thing
+ * that was rejected.
+ */
+function assertLocalDirectoryArgument(dir) {
+    if (typeof dir !== 'string' || dir.trim().length === 0) {
+        throw new Error(`skillsFromDir: expected a local directory path, got ${JSON.stringify(dir)}.`);
+    }
+    const scheme = URL_LIKE_RE.exec(dir);
+    if (scheme) {
+        throw new Error(`skillsFromDir: '${dir}' is a ${scheme[0].slice(0, -3)} URL, not a local directory. ` +
+            `Skill bodies are instructions to a model, so this loader only reads files you own ` +
+            `at build time — fetch remote content yourself, review it, and pass defineSkill(...) ` +
+            `the result.`);
+    }
+    if (dir.startsWith('\\\\')) {
+        throw new Error(`skillsFromDir: '${dir}' is a network (UNC) path, not a local directory. ` +
+            `Skill bodies are instructions to a model, so this loader only reads files you own ` +
+            `at build time.`);
+    }
+}
+// ─── Frontmatter ───────────────────────────────────────────────────
+/**
+ * Parse one `SKILL.md`. Every refusal names the file — a loader that says
+ * "malformed frontmatter" over a directory of forty files has told you nothing.
+ *
+ * The grammar is deliberately small: an opening `---` line, `key: value` lines
+ * (`#` comments and blank lines skipped, single/double quotes stripped), a
+ * closing `---` line, then the body. Keys other than `name` and `description`
+ * are IGNORED rather than rejected, so a file carrying extra frontmatter for
+ * another tool still loads here.
+ */
+function parseSkillFile(raw, file) {
+    // Strip a UTF-8 BOM — an editor artifact, not the author's intent.
+    const text = raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw;
+    const lines = text.split(/\r?\n/);
+    if (lines[0]?.trim() !== '---') {
+        throw new Error(`skillsFromDir: '${file}' does not start with a '---' frontmatter block. ` +
+            `Expected:\n---\nname: my-skill\ndescription: When to use it.\n---\n<the body>`);
+    }
+    const closingIndex = lines.findIndex((line, i) => i > 0 && line.trim() === '---');
+    if (closingIndex === -1) {
+        throw new Error(`skillsFromDir: '${file}' opens a '---' frontmatter block that is never closed. ` +
+            `Add a '---' line after the last frontmatter key.`);
+    }
+    const fields = new Map();
+    for (let i = 1; i < closingIndex; i++) {
+        const line = lines[i] ?? '';
+        if (line.trim().length === 0 || line.trimStart().startsWith('#'))
+            continue;
+        const separator = line.indexOf(':');
+        if (separator === -1) {
+            throw new Error(`skillsFromDir: '${file}' frontmatter line ${i + 1} is not 'key: value' — got ` +
+                `${JSON.stringify(line)}.`);
+        }
+        const key = line.slice(0, separator).trim();
+        if (key.length === 0) {
+            throw new Error(`skillsFromDir: '${file}' frontmatter line ${i + 1} has an empty key — got ` +
+                `${JSON.stringify(line)}.`);
+        }
+        fields.set(key, unquote(line.slice(separator + 1).trim()));
+    }
+    const name = fields.get('name') ?? '';
+    const description = fields.get('description') ?? '';
+    const body = lines
+        .slice(closingIndex + 1)
+        .join('\n')
+        .trim();
+    if (name.length === 0) {
+        throw new Error(`skillsFromDir: '${file}' frontmatter is missing 'name'. It becomes the skill id the ` +
+            `model passes to read_skill.`);
+    }
+    if (!SKILL_NAME_RE.test(name)) {
+        throw new Error(`skillsFromDir: '${file}' frontmatter name '${name}' must match ` +
+            `/^[a-zA-Z0-9_-]{1,64}$/ — it is the id the model passes to read_skill.`);
+    }
+    if (description.length === 0) {
+        throw new Error(`skillsFromDir: '${file}' frontmatter is missing 'description'. It is the ONLY thing ` +
+            `the model reads when deciding whether to open this skill.`);
+    }
+    if (body.length === 0) {
+        throw new Error(`skillsFromDir: '${file}' has no body after the closing '---'. The body is what the ` +
+            `model reads once it activates the skill.`);
+    }
+    return { name, description, body, file };
+}
+/** Strip one layer of matching single or double quotes from a YAML-ish scalar. */
+function unquote(value) {
+    if (value.length >= 2) {
+        const first = value[0];
+        const last = value[value.length - 1];
+        if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+            return value.slice(1, -1);
+        }
+    }
+    return value;
+}
+//# sourceMappingURL=skillsFromDir.js.map

package/dist/esm/lib/injection-engine/skillsFromDir.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skillsFromDir.js","sourceRoot":"","sources":["../../../../src/lib/injection-engine/skillsFromDir.ts"],"names":[],"mappings":"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"}

package/dist/esm/lib/mcp/index.d.ts

@@ -1,9 +1,10 @@
 /**
- * MCP — Model Context Protocol client integration. Connect to an MCP
- * server, register its tools on your Agent. Server-side support is
- * separate (consumer exposes their agent as an MCP tool — different
- * use case, not yet shipped).
+ * MCP — Model Context Protocol, both directions. `mcpClient` connects to
+ * someone else's MCP server and registers its tools on your Agent;
+ * `mcpServe` exposes your own tools AS an MCP server so any MCP client
+ * can call them.
  */
 export { mcpClient } from './mcpClient.js';
+export { mcpServe } from './mcpServe.js';
 export { mockMcpClient, type MockMcpClientOptions, type MockMcpTool } from './mockMcpClient.js';
-export type { McpClient, McpClientOptions, McpHttpTransport, McpStdioTransport, McpTransport, McpSdkClient, } from './types.js';
+export type { McpClient, McpClientOptions, McpHttpTransport, McpStdioTransport, McpTransport, McpSdkClient, McpServeOptions, McpServeHandle, McpServeTransport, McpHttpServeTransport, McpStdioServeTransport, McpSdkServer, } from './types.js';

package/dist/esm/lib/mcp/index.js

@@ -1,9 +1,10 @@
 /**
- * MCP — Model Context Protocol client integration. Connect to an MCP
- * server, register its tools on your Agent. Server-side support is
- * separate (consumer exposes their agent as an MCP tool — different
- * use case, not yet shipped).
+ * MCP — Model Context Protocol, both directions. `mcpClient` connects to
+ * someone else's MCP server and registers its tools on your Agent;
+ * `mcpServe` exposes your own tools AS an MCP server so any MCP client
+ * can call them.
  */
 export { mcpClient } from './mcpClient.js';
+export { mcpServe } from './mcpServe.js';
 export { mockMcpClient } from './mockMcpClient.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/lib/mcp/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/lib/mcp/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,aAAa,EAA+C,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/lib/mcp/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,aAAa,EAA+C,MAAM,oBAAoB,CAAC"}