@miragon/mcp-toolkit-core 0.10.1

package/dist/tools/register-widget-tool.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { uiMeta } from "../types/meta.js";
+import { withToolErrors } from "./with-tool-errors.js";
+/** Normalizes the {@link WidgetToolConfig.visibility} option into a flag set. */
+function resolveVisibility(visibility) {
+    const list = visibility === undefined ? ["app"] : Array.isArray(visibility) ? visibility : [visibility];
+    return { app: list.includes("app"), model: list.includes("model") };
+}
+export function createWidgetToolRegistrar(server, client, resourceUri, metaDefaults) {
+    return function register(config) {
+        const { app, model } = resolveVisibility(config.visibility);
+        // `"model"`-visible tools must not carry the app-only `visibility` marker so
+        // the LLM still sees them; otherwise mark app-only. The `resourceUri` is
+        // always present so the host knows which bundle renders the result.
+        // Model-visible tools additionally get the dual-protocol widget contract
+        // (flat `ui/resourceUri` + `openai/*` keys) ext-apps hosts key on.
+        const ui = uiMeta({
+            resourceUri,
+            appOnly: app && !model,
+            title: config.title ?? config.name,
+            invoking: config.invoking,
+            invoked: config.invoked,
+            widgetDescription: config.description,
+            widgetCSP: metaDefaults?.widgetCSP,
+        });
+        server.tool({
+            name: config.name,
+            title: config.title,
+            description: config.description,
+            schema: config.inputSchema ? z.object(config.inputSchema) : undefined,
+            annotations: config.annotations,
+            _meta: { ...config.meta, ...ui },
+        }, 
+        // The SDK validates params against the schema above, so the loose
+        // callback param is safely the handler's precise `ToolArgs<TShape>`.
+        withToolErrors(async (looseParams) => {
+            const result = await config.handler(client, looseParams);
+            return {
+                content: [{ type: "text", text: result.text }],
+                structuredContent: result.structuredContent,
+            };
+        }));
+    };
+}
+//# sourceMappingURL=register-widget-tool.js.map

package/dist/tools/register-widget-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-widget-tool.js","sourceRoot":"","sources":["../../src/tools/register-widget-tool.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAE,MAAM,EAA+B,MAAM,kBAAkB,CAAA;AACtE,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAsDtD,iFAAiF;AACjF,SAAS,iBAAiB,CAAC,UAA4C;IAIrE,MAAM,IAAI,GACR,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAA;IAC5F,OAAO,EAAE,GAAG,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAA;AACrE,CAAC;AAED,MAAM,UAAU,yBAAyB,CACvC,MAAiB,EACjB,MAAe,EACf,WAAmB,EACnB,YAAqC;IAErC,OAAO,SAAS,QAAQ,CACtB,MAAyC;QAEzC,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,iBAAiB,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;QAC3D,6EAA6E;QAC7E,yEAAyE;QACzE,oEAAoE;QACpE,yEAAyE;QACzE,mEAAmE;QACnE,MAAM,EAAE,GAAG,MAAM,CAAC;YAChB,WAAW;YACX,OAAO,EAAE,GAAG,IAAI,CAAC,KAAK;YACtB,KAAK,EAAE,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,IAAI;YAClC,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,iBAAiB,EAAE,MAAM,CAAC,WAAW;YACrC,SAAS,EAAE,YAAY,EAAE,SAAS;SACnC,CAAC,CAAA;QAEF,MAAM,CAAC,IAAI,CACT;YACE,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,KAAK,EAAE,MAAM,CAAC,KAAK;YACnB,WAAW,EAAE,MAAM,CAAC,WAAW;YAC/B,MAAM,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,SAAS;YACrE,WAAW,EAAE,MAAM,CAAC,WAAW;YAC/B,KAAK,EAAE,EAAE,GAAG,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE;SACjC;QACD,kEAAkE;QAClE,qEAAqE;QACrE,cAAc,CAAC,KAAK,EAAE,WAA0B,EAAE,EAAE;YAClD,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,WAA+B,CAAC,CAAA;YAC5E,OAAO;gBACL,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAe,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC;gBACvD,iBAAiB,EAAE,MAAM,CAAC,iBAAiB;aAC5C,CAAA;QACH,CAAC,CAAC,CACH,CAAA;IACH,CAAC,CAAA;AACH,CAAC"}

package/dist/tools/tool-call-name.d.ts

@@ -0,0 +1,53 @@
+import { type McpServerInstance } from "mcp-use/server";
+/**
+ * Resolves the tool name of the in-flight `tools/call` request, or
+ * `undefined` when called outside a tool-call request scope.
+ *
+ * Backs the role-filter's `tools/call` guard: mcp-use 1.28 passes only the
+ * tool *arguments* to `mcp:tools/call` middleware as `ctx.params`, so the
+ * `params.name` its typings declare is never populated at runtime. This
+ * resolver recovers the real name from the JSON-RPC envelope captured at the
+ * HTTP layer.
+ */
+export type ToolNameResolver = () => string | undefined;
+/**
+ * The resolver returned by {@link installToolCallNameCapture}: callable as a
+ * plain {@link ToolNameResolver} (first `tools/call` name — the common case
+ * and the logging-friendly one), with `.all()` exposing every name the
+ * in-flight envelope carries. A JSON-RPC *batch* can contain several
+ * `tools/call` requests, and a guard that only checks one of them can be
+ * bypassed by the others — the role filter therefore consumes `.all()`.
+ */
+export interface ToolNameCapture extends ToolNameResolver {
+    /** Every `tools/call` name in the in-flight envelope, or `undefined` outside a capture scope. */
+    all: () => string[] | undefined;
+}
+/**
+ * Parse a JSON-RPC request body and return the `params.name` of every
+ * `tools/call` request it carries: a single request yields zero or one entry,
+ * a batch array yields one entry per `tools/call` it contains. Batches are a
+ * real-world shape, not an edge case — Streamable-HTTP revision 2025-03-26
+ * allows them, and claude.ai (via mcp-remote) frames single calls as
+ * one-element batches.
+ *
+ * Pure and side-effect free so it can be unit-tested without an HTTP server.
+ * Tolerates arbitrary `unknown` input: malformed bodies, malformed batch
+ * entries, and non-`tools/call` methods contribute nothing rather than throw.
+ */
+export declare function extractToolCallNames(body: unknown): string[];
+/**
+ * First `tools/call` name of a JSON-RPC request body (single request or batch
+ * array), or `undefined` when it carries none. Sufficient for logging; guards
+ * must use {@link extractToolCallNames} — a batch can carry several calls.
+ */
+export declare function extractToolCallName(body: unknown): string | undefined;
+/**
+ * Whether `path` is one of the MCP transport endpoints mcp-use mounts the
+ * Streamable-HTTP handler at. Both `/mcp` and `/sse` accept `tools/call`, so
+ * the tool-name capture (and the role-filter guard that reads it) must cover
+ * both — matching only `/mcp` leaves a `tools/call` over `/sse` unguarded.
+ * Exported so the endpoint contract is pinned by a unit test.
+ */
+export declare function isMcpTransportPath(path: string): boolean;
+export declare function installToolCallNameCapture(server: McpServerInstance<boolean>): ToolNameCapture;
+//# sourceMappingURL=tool-call-name.d.ts.map

package/dist/tools/tool-call-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call-name.d.ts","sourceRoot":"","sources":["../../src/tools/tool-call-name.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAS1E;;;;;;;;;GASG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,MAAM,GAAG,SAAS,CAAA;AAEvD;;;;;;;GAOG;AACH,MAAM,WAAW,eAAgB,SAAQ,gBAAgB;IACvD,iGAAiG;IACjG,GAAG,EAAE,MAAM,MAAM,EAAE,GAAG,SAAS,CAAA;CAChC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,EAAE,CAU5D;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAErE;AA0BD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,iBAAiB,CAAC,OAAO,CAAC,GAAG,eAAe,CAuB9F"}

package/dist/tools/tool-call-name.js

@@ -0,0 +1,92 @@
+import { getRequestContext } from "mcp-use/server";
+/**
+ * Parse a JSON-RPC request body and return the `params.name` of every
+ * `tools/call` request it carries: a single request yields zero or one entry,
+ * a batch array yields one entry per `tools/call` it contains. Batches are a
+ * real-world shape, not an edge case — Streamable-HTTP revision 2025-03-26
+ * allows them, and claude.ai (via mcp-remote) frames single calls as
+ * one-element batches.
+ *
+ * Pure and side-effect free so it can be unit-tested without an HTTP server.
+ * Tolerates arbitrary `unknown` input: malformed bodies, malformed batch
+ * entries, and non-`tools/call` methods contribute nothing rather than throw.
+ */
+export function extractToolCallNames(body) {
+    if (Array.isArray(body)) {
+        return body.flatMap((entry) => extractToolCallNames(entry));
+    }
+    if (typeof body !== "object" || body === null)
+        return [];
+    const { method, params } = body;
+    if (method !== "tools/call")
+        return [];
+    if (typeof params !== "object" || params === null)
+        return [];
+    const { name } = params;
+    return typeof name === "string" ? [name] : [];
+}
+/**
+ * First `tools/call` name of a JSON-RPC request body (single request or batch
+ * array), or `undefined` when it carries none. Sufficient for logging; guards
+ * must use {@link extractToolCallNames} — a batch can carry several calls.
+ */
+export function extractToolCallName(body) {
+    return extractToolCallNames(body)[0];
+}
+/**
+ * Capture the `tools/call` tool name at the HTTP layer and expose it to the
+ * MCP middleware chain.
+ *
+ * Registers a Hono middleware on the server that, for `POST` requests to an
+ * MCP transport endpoint, clones the request body (so the MCP transport can
+ * still read it), parses the JSON-RPC envelope, and — when it's a
+ * `tools/call` — stashes the tool name in a `WeakMap` keyed by the
+ * request-scoped Hono context. The returned resolver reads that map back via
+ * `getRequestContext()`, which yields the same context inside the MCP
+ * middleware chain.
+ *
+ * mcp-use mounts the *same* Streamable-HTTP handler at both `/mcp` and `/sse`
+ * (`for (const endpoint of ["/mcp", "/sse"])`), so the capture must match both
+ * — otherwise a `tools/call` sent to `/sse` executes but its name is never
+ * captured, and the role-filter guard that depends on this resolver silently
+ * falls open. Matching both endpoints closes that bypass.
+ *
+ * The `WeakMap` keying keeps the capture request-isolated: entries are
+ * garbage-collected with their context and never leak across concurrent
+ * requests.
+ */
+const MCP_TRANSPORT_PATHS = new Set(["/mcp", "/sse"]);
+/**
+ * Whether `path` is one of the MCP transport endpoints mcp-use mounts the
+ * Streamable-HTTP handler at. Both `/mcp` and `/sse` accept `tools/call`, so
+ * the tool-name capture (and the role-filter guard that reads it) must cover
+ * both — matching only `/mcp` leaves a `tools/call` over `/sse` unguarded.
+ * Exported so the endpoint contract is pinned by a unit test.
+ */
+export function isMcpTransportPath(path) {
+    return MCP_TRANSPORT_PATHS.has(path);
+}
+export function installToolCallNameCapture(server) {
+    const toolNamesByRequest = new WeakMap();
+    server.use(async (c, next) => {
+        if (c.req.method === "POST" && isMcpTransportPath(c.req.path)) {
+            const body = await c.req.raw
+                .clone()
+                .json()
+                .catch(() => undefined);
+            const toolNames = extractToolCallNames(body);
+            if (toolNames.length > 0) {
+                toolNamesByRequest.set(c, toolNames);
+            }
+        }
+        await next();
+    });
+    const all = () => {
+        const requestContext = getRequestContext();
+        if (!requestContext)
+            return undefined;
+        return toolNamesByRequest.get(requestContext);
+    };
+    return Object.assign(() => all()?.[0], { all });
+}
+//# sourceMappingURL=tool-call-name.js.map

package/dist/tools/tool-call-name.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call-name.js","sourceRoot":"","sources":["../../src/tools/tool-call-name.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAA0B,MAAM,gBAAgB,CAAA;AAkC1E;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAa;IAChD,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QACxB,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,CAAA;IAC7D,CAAC;IACD,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,EAAE,CAAA;IACxD,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,IAA8C,CAAA;IACzE,IAAI,MAAM,KAAK,YAAY;QAAE,OAAO,EAAE,CAAA;IACtC,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,IAAI;QAAE,OAAO,EAAE,CAAA;IAC5D,MAAM,EAAE,IAAI,EAAE,GAAG,MAA4B,CAAA;IAC7C,OAAO,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAA;AAC/C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAa;IAC/C,OAAO,oBAAoB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;AACtC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,mBAAmB,GAAG,IAAI,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;AAErD;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAY;IAC7C,OAAO,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;AACtC,CAAC;AAED,MAAM,UAAU,0BAA0B,CAAC,MAAkC;IAC3E,MAAM,kBAAkB,GAAG,IAAI,OAAO,EAAyB,CAAA;IAE/D,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE;QAC3B,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM,KAAK,MAAM,IAAI,kBAAkB,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YAC9D,MAAM,IAAI,GAAY,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG;iBAClC,KAAK,EAAE;iBACP,IAAI,EAAE;iBACN,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAA;YACzB,MAAM,SAAS,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAA;YAC5C,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACzB,kBAAkB,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,CAAC,CAAA;YACtC,CAAC;QACH,CAAC;QACD,MAAM,IAAI,EAAE,CAAA;IACd,CAAC,CAAC,CAAA;IAEF,MAAM,GAAG,GAAG,GAAyB,EAAE;QACrC,MAAM,cAAc,GAAG,iBAAiB,EAAE,CAAA;QAC1C,IAAI,CAAC,cAAc;YAAE,OAAO,SAAS,CAAA;QACrC,OAAO,kBAAkB,CAAC,GAAG,CAAC,cAAc,CAAC,CAAA;IAC/C,CAAC,CAAA;IACD,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,CAAA;AACjD,CAAC"}

package/dist/tools/with-tool-errors.d.ts

@@ -0,0 +1,16 @@
+import { error } from "mcp-use/server";
+/**
+ * Wraps a raw `server.tool()` handler so thrown exceptions surface as the same
+ * `error("[code] message")` tool result the toolkit's registrars produce. This
+ * is the single source of truth for the registrar error format — both
+ * `createToolRegistrar` and `createWidgetToolRegistrar` route their `catch`
+ * paths through here, and tools that bypass the registrars (widget tools,
+ * `*_data` feeds) can wrap their handlers to follow the house "use `error()`,
+ * don't throw" convention.
+ *
+ * Code precedence matches the registrars: an HTTP-ish `status` (e.g. `404`)
+ * wins over a domain error `code` (e.g. `ENGINE_NOT_SELECTED`); both may be a
+ * `string` or `number`. When neither is present the message is returned as-is.
+ */
+export declare function withToolErrors<TArgs extends unknown[], TResult>(handler: (...args: TArgs) => Promise<TResult>): (...args: TArgs) => Promise<TResult | ReturnType<typeof error>>;
+//# sourceMappingURL=with-tool-errors.d.ts.map

package/dist/tools/with-tool-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-tool-errors.d.ts","sourceRoot":"","sources":["../../src/tools/with-tool-errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAEtC;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,EAC7D,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,CAAC,OAAO,CAAC,GAC5C,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,KAAK,CAAC,CAAC,CAWjE"}

package/dist/tools/with-tool-errors.js

@@ -0,0 +1,28 @@
+import { error } from "mcp-use/server";
+/**
+ * Wraps a raw `server.tool()` handler so thrown exceptions surface as the same
+ * `error("[code] message")` tool result the toolkit's registrars produce. This
+ * is the single source of truth for the registrar error format — both
+ * `createToolRegistrar` and `createWidgetToolRegistrar` route their `catch`
+ * paths through here, and tools that bypass the registrars (widget tools,
+ * `*_data` feeds) can wrap their handlers to follow the house "use `error()`,
+ * don't throw" convention.
+ *
+ * Code precedence matches the registrars: an HTTP-ish `status` (e.g. `404`)
+ * wins over a domain error `code` (e.g. `ENGINE_NOT_SELECTED`); both may be a
+ * `string` or `number`. When neither is present the message is returned as-is.
+ */
+export function withToolErrors(handler) {
+    return async (...args) => {
+        try {
+            return await handler(...args);
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            const { status, code } = (e ?? {});
+            const errorCode = status ?? code;
+            return error(errorCode ? `[${errorCode}] ${message}` : message);
+        }
+    };
+}
+//# sourceMappingURL=with-tool-errors.js.map

package/dist/tools/with-tool-errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-tool-errors.js","sourceRoot":"","sources":["../../src/tools/with-tool-errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAEtC;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,cAAc,CAC5B,OAA6C;IAE7C,OAAO,KAAK,EAAE,GAAG,IAAI,EAAE,EAAE;QACvB,IAAI,CAAC;YACH,OAAO,MAAM,OAAO,CAAC,GAAG,IAAI,CAAC,CAAA;QAC/B,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,MAAM,OAAO,GAAG,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;YAC1D,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAyD,CAAA;YAC1F,MAAM,SAAS,GAAG,MAAM,IAAI,IAAI,CAAA;YAChC,OAAO,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,SAAS,KAAK,OAAO,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAA;QACjE,CAAC;IACH,CAAC,CAAA;AACH,CAAC"}

package/dist/types/app.d.ts

@@ -0,0 +1,44 @@
+import type { WidgetToolMetaDefaults } from "./meta.js";
+import type { PipelineStepDefinition } from "./step.js";
+import type { WidgetDefinition } from "./widget.js";
+export interface AppDefinition {
+    name: string;
+    steps: PipelineStepDefinition<any>[];
+    widgets: WidgetDefinition[];
+}
+/**
+ * An AppPlugin bundles everything an app contributes to the framework:
+ * - The AppDefinition (steps + widgets)
+ * - Optional functions to register domain tools and widget tools on an MCP server
+ *
+ * The server type is generic so consumers can pass the concrete `MCPServer`
+ * type from `mcp-use/server` without the toolkit itself having to import from
+ * `mcp-use`. This keeps the core barrel free of mcp-use type dependencies,
+ * which avoids transitive type leaks (hono versions, langchain chunks, etc.)
+ * when the pre-built core `dist/` is shared between projects with diverging
+ * peer dep resolutions.
+ *
+ * Each app exports a `createPlugin(config)` factory that returns an
+ * `AppPlugin<MCPServer>`.
+ */
+export interface AppPlugin<TServer = unknown> {
+    definition: AppDefinition;
+    /**
+     * Configuration handed to this plugin's pipeline steps as their second
+     * `execute` argument. May carry closures — e.g. a typed `callTool` bound to
+     * the module's own store or client — which the pipeline executor rewraps
+     * with the per-request user context (see `pipeline-executor.ts:bindAppConfig`).
+     */
+    appConfig?: Record<string, unknown>;
+    registerTools?: (server: TServer) => void;
+    /**
+     * Registers the plugin's widget tools against the shared app resource.
+     * The optional `metaDefaults` carry app-level widget `_meta` defaults
+     * (currently the Apps SDK CSP) — forward them into
+     * `createWidgetToolRegistrar` / `uiMeta` so every widget tool advertises
+     * the same contract as the framework's own `render-view`. Implementations
+     * may ignore the parameter; their tools then simply omit those keys.
+     */
+    registerWidgetTools?: (server: TServer, resourceUri: string, metaDefaults?: WidgetToolMetaDefaults) => void;
+}
+//# sourceMappingURL=app.d.ts.map

package/dist/types/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../src/types/app.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAA;AACvD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAA;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IAMZ,KAAK,EAAE,sBAAsB,CAAC,GAAG,CAAC,EAAE,CAAA;IACpC,OAAO,EAAE,gBAAgB,EAAE,CAAA;CAC5B;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,SAAS,CAAC,OAAO,GAAG,OAAO;IAC1C,UAAU,EAAE,aAAa,CAAA;IACzB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACnC,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAA;IACzC;;;;;;;OAOG;IACH,mBAAmB,CAAC,EAAE,CACpB,MAAM,EAAE,OAAO,EACf,WAAW,EAAE,MAAM,EACnB,YAAY,CAAC,EAAE,sBAAsB,KAClC,IAAI,CAAA;CACV"}

package/dist/types/app.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=app.js.map

package/dist/types/app.js.map

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

package/dist/types/config.d.ts

@@ -0,0 +1,15 @@
+import type { PipelineConfig } from "./pipeline.js";
+export interface AppConfigEntry {
+    app: string;
+    config: Record<string, unknown>;
+}
+export interface AppConfig {
+    activeApps: AppConfigEntry[];
+    pipelines: Record<string, PipelineConfig>;
+}
+export interface ValidationResult {
+    valid: boolean;
+    issues: string[];
+    availableKeys: string[];
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/types/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/types/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAEnD,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAChC;AAED,MAAM,WAAW,SAAS;IACxB,UAAU,EAAE,cAAc,EAAE,CAAA;IAC5B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;CAC1C;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAA;IACd,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,aAAa,EAAE,MAAM,EAAE,CAAA;CACxB"}

package/dist/types/config.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=config.js.map

package/dist/types/config.js.map

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

package/dist/types/context.d.ts

@@ -0,0 +1,18 @@
+export interface StepOutput {
+    data: unknown;
+    keys: Record<string, unknown>;
+    _app: string;
+    _step: string;
+}
+export interface StepResult extends StepOutput {
+    _dataType: string;
+}
+export interface PipelineContext {
+    steps: Record<string, StepResult>;
+    keys: Record<string, unknown>;
+    errors: {
+        stepId: string;
+        reason: string;
+    }[];
+}
+//# sourceMappingURL=context.d.ts.map

package/dist/types/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/types/context.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,OAAO,CAAA;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,UAAW,SAAQ,UAAU;IAC5C,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;IACjC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7B,MAAM,EAAE;QACN,MAAM,EAAE,MAAM,CAAA;QACd,MAAM,EAAE,MAAM,CAAA;KACf,EAAE,CAAA;CACJ"}

package/dist/types/context.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=context.js.map

package/dist/types/context.js.map

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

package/dist/types/index.d.ts

@@ -0,0 +1,10 @@
+export type { StepOutput, StepResult, PipelineContext } from "./context.js";
+export type { PipelineStepDefinition, OptionalKeyDeclaration } from "./step.js";
+export type { WidgetProps, WidgetSize, WidgetDefinition } from "./widget.js";
+export type { AppDefinition, AppPlugin } from "./app.js";
+export type { PipelineConfig, PipelineStepRef } from "./pipeline.js";
+export type { AppConfig, AppConfigEntry, ValidationResult } from "./config.js";
+export type { ViewStructuredContent, StepDataEntry, RefreshParams } from "./view-data.js";
+export { APP_ONLY_META, uiMeta } from "./meta.js";
+export type { UiMetaOptions, UiToolMeta, WidgetCspMeta, WidgetToolMetaDefaults } from "./meta.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC3E,YAAY,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAA;AAC/E,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAC5E,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AACxD,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AACpE,YAAY,EAAE,SAAS,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAC9E,YAAY,EAAE,qBAAqB,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AACzF,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AACjD,YAAY,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAA"}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+export { APP_ONLY_META, uiMeta } from "./meta.js";
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA"}

package/dist/types/meta.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Shared `_meta` shapes for widget tools: the SEP-1865 tool-visibility
+ * convention plus the dual-protocol widget contract (MCP Apps + OpenAI
+ * Apps SDK) that ext-apps hosts key on.
+ *
+ * Browser-bundle-safe: this module is a pure object/function with no
+ * `mcp-use/server` or `node:*` imports, so it can be re-exported from the core
+ * Root barrel and consumed by UI bundles as well as server registrars. The
+ * dual-protocol key literals are therefore written out here instead of being
+ * imported from `mcp-use/server`; `meta.test.ts` pins them against the
+ * adapters mcp-use itself emits (`McpAppsAdapter`/`AppsSdkAdapter`), so a
+ * contract drift in a future mcp-use bump fails CI instead of silently
+ * breaking widget rendering on Claude Desktop / claude.ai again.
+ *
+ * SEP-1865 (`_meta.ui.visibility`): conforming MCP hosts hide tools marked
+ * `visibility: ["app"]` from the LLM's `tools/list` while keeping them callable
+ * from inside a widget iframe via `callTool`. Non-conforming hosts ignore the
+ * marker and fall back to the tool description.
+ */
+/**
+ * App-only marker — hides a tool from the LLM tool surface while leaving it
+ * callable from widgets. Deliberately carries no `resourceUri`: app-only tools
+ * (`*_data` feeds, catalogue/refresh hooks) return JSON, they do not render UI.
+ */
+export declare const APP_ONLY_META: {
+    readonly ui: {
+        readonly visibility: readonly ["app"];
+    };
+};
+/**
+ * The Apps SDK `openai/widgetCSP` shape (snake_cased, as emitted on the wire
+ * by mcp-use's `AppsSdkAdapter`). All domains are full origins
+ * (e.g. `https://server.example`).
+ */
+export interface WidgetCspMeta {
+    /** Origins allowed for fetch/XHR/WebSocket from inside the widget iframe. */
+    connect_domains?: string[];
+    /** Origins allowed for images, scripts, stylesheets, fonts. */
+    resource_domains?: string[];
+    /** Allowed iframe origins. */
+    frame_domains?: string[];
+    /** Allowed `base-uri` origins (SEP-1865). */
+    base_uri_domains?: string[];
+}
+/**
+ * Per-app widget-tool `_meta` defaults the framework threads into each
+ * plugin's `registerWidgetTools` hook (third parameter) so every widget tool
+ * can advertise them without knowing app-level configuration.
+ */
+export interface WidgetToolMetaDefaults {
+    /** Content-security policy advertised to Apps SDK hosts (`openai/widgetCSP`). */
+    widgetCSP?: WidgetCspMeta;
+}
+/** Options for {@link uiMeta}. */
+export interface UiMetaOptions {
+    /**
+     * The MCP UI resource URI hosting the widget bundle. When set, the host
+     * renders the tool result into that resource instead of returning it.
+     */
+    resourceUri?: string;
+    /** When `true`, marks the tool app-only via SEP-1865 `visibility: ["app"]`. */
+    appOnly?: boolean;
+    /**
+     * Display name used to derive the default `invoking`/`invoked` status
+     * strings (mirroring mcp-use's `Loading <name>...` / `<name> ready`
+     * defaults). Typically the tool title.
+     */
+    title?: string;
+    /** Host status line while the tool call runs (`openai/toolInvocation/invoking`). */
+    invoking?: string;
+    /** Host status line once the tool call finished (`openai/toolInvocation/invoked`). */
+    invoked?: string;
+    /** Widget description surfaced to Apps SDK hosts (`openai/widgetDescription`). */
+    widgetDescription?: string;
+    /** Content-security policy advertised to Apps SDK hosts (`openai/widgetCSP`). */
+    widgetCSP?: WidgetCspMeta;
+}
+/** Return shape of {@link uiMeta}: the nested `ui` block plus flat wire keys. */
+export interface UiToolMeta extends Record<string, unknown> {
+    ui: Record<string, unknown>;
+}
+/**
+ * Builds the `_meta` object for a tool from a {@link UiMetaOptions}, keeping
+ * the SEP-1865 visibility / resourceUri literals in one place. Omitted fields
+ * are left off entirely so the emitted `_meta` matches the hand-written
+ * literals it replaces.
+ *
+ * Widget-RENDERING tools (a `resourceUri` and not app-only) additionally get
+ * the dual-protocol widget contract that mcp-use emits natively for `mcpApps`
+ * widgets — the flat SEP-1865 key plus the `openai/*` Apps SDK keys. Ext-apps
+ * hosts (Claude Desktop / claude.ai) key on these to recognise the tool as
+ * widget-producing and to deliver `structuredContent` to the iframe; without
+ * them every widget hangs on its loading skeleton. App-only tools stay free
+ * of the widget keys on purpose: their results are consumed by an already
+ * rendered widget via `callTool`, and advertising an output template would
+ * invite hosts to render them.
+ */
+export declare function uiMeta(opts: UiMetaOptions): UiToolMeta;
+//# sourceMappingURL=meta.d.ts.map

package/dist/types/meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta.d.ts","sourceRoot":"","sources":["../../src/types/meta.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;CAA2C,CAAA;AAErE;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,6EAA6E;IAC7E,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;IAC1B,+DAA+D;IAC/D,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC3B,8BAA8B;IAC9B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;IACxB,6CAA6C;IAC7C,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,iFAAiF;IACjF,SAAS,CAAC,EAAE,aAAa,CAAA;CAC1B;AAED,kCAAkC;AAClC,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,+EAA+E;IAC/E,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,oFAAoF;IACpF,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,sFAAsF;IACtF,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,kFAAkF;IAClF,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,iFAAiF;IACjF,SAAS,CAAC,EAAE,aAAa,CAAA;CAC1B;AAED,iFAAiF;AACjF,MAAM,WAAW,UAAW,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACzD,EAAE,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC5B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,UAAU,CAqBtD"}

package/dist/types/meta.js

@@ -0,0 +1,66 @@
+/**
+ * Shared `_meta` shapes for widget tools: the SEP-1865 tool-visibility
+ * convention plus the dual-protocol widget contract (MCP Apps + OpenAI
+ * Apps SDK) that ext-apps hosts key on.
+ *
+ * Browser-bundle-safe: this module is a pure object/function with no
+ * `mcp-use/server` or `node:*` imports, so it can be re-exported from the core
+ * Root barrel and consumed by UI bundles as well as server registrars. The
+ * dual-protocol key literals are therefore written out here instead of being
+ * imported from `mcp-use/server`; `meta.test.ts` pins them against the
+ * adapters mcp-use itself emits (`McpAppsAdapter`/`AppsSdkAdapter`), so a
+ * contract drift in a future mcp-use bump fails CI instead of silently
+ * breaking widget rendering on Claude Desktop / claude.ai again.
+ *
+ * SEP-1865 (`_meta.ui.visibility`): conforming MCP hosts hide tools marked
+ * `visibility: ["app"]` from the LLM's `tools/list` while keeping them callable
+ * from inside a widget iframe via `callTool`. Non-conforming hosts ignore the
+ * marker and fall back to the tool description.
+ */
+/**
+ * App-only marker — hides a tool from the LLM tool surface while leaving it
+ * callable from widgets. Deliberately carries no `resourceUri`: app-only tools
+ * (`*_data` feeds, catalogue/refresh hooks) return JSON, they do not render UI.
+ */
+export const APP_ONLY_META = { ui: { visibility: ["app"] } };
+/**
+ * Builds the `_meta` object for a tool from a {@link UiMetaOptions}, keeping
+ * the SEP-1865 visibility / resourceUri literals in one place. Omitted fields
+ * are left off entirely so the emitted `_meta` matches the hand-written
+ * literals it replaces.
+ *
+ * Widget-RENDERING tools (a `resourceUri` and not app-only) additionally get
+ * the dual-protocol widget contract that mcp-use emits natively for `mcpApps`
+ * widgets — the flat SEP-1865 key plus the `openai/*` Apps SDK keys. Ext-apps
+ * hosts (Claude Desktop / claude.ai) key on these to recognise the tool as
+ * widget-producing and to deliver `structuredContent` to the iframe; without
+ * them every widget hangs on its loading skeleton. App-only tools stay free
+ * of the widget keys on purpose: their results are consumed by an already
+ * rendered widget via `callTool`, and advertising an output template would
+ * invite hosts to render them.
+ */
+export function uiMeta(opts) {
+    const ui = {};
+    if (opts.resourceUri !== undefined)
+        ui.resourceUri = opts.resourceUri;
+    if (opts.appOnly)
+        ui.visibility = ["app"];
+    const meta = { ui };
+    if (opts.resourceUri !== undefined && !opts.appOnly) {
+        meta["ui/resourceUri"] = opts.resourceUri;
+        meta["openai/outputTemplate"] = opts.resourceUri;
+        meta["openai/toolInvocation/invoking"] =
+            opts.invoking ?? (opts.title ? `Loading ${opts.title}...` : "Loading view...");
+        meta["openai/toolInvocation/invoked"] =
+            opts.invoked ?? (opts.title ? `${opts.title} ready` : "View ready");
+        meta["openai/widgetAccessible"] = true;
+        meta["openai/resultCanProduceWidget"] = true;
+        if (opts.widgetDescription !== undefined) {
+            meta["openai/widgetDescription"] = opts.widgetDescription;
+        }
+        if (opts.widgetCSP !== undefined)
+            meta["openai/widgetCSP"] = opts.widgetCSP;
+    }
+    return meta;
+}
+//# sourceMappingURL=meta.js.map

package/dist/types/meta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta.js","sourceRoot":"","sources":["../../src/types/meta.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,EAAE,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC,KAAK,CAAC,EAAE,EAAW,CAAA;AA0DrE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,MAAM,CAAC,IAAmB;IACxC,MAAM,EAAE,GAA4B,EAAE,CAAA;IACtC,IAAI,IAAI,CAAC,WAAW,KAAK,SAAS;QAAE,EAAE,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAA;IACrE,IAAI,IAAI,CAAC,OAAO;QAAE,EAAE,CAAC,UAAU,GAAG,CAAC,KAAK,CAAC,CAAA;IAEzC,MAAM,IAAI,GAAe,EAAE,EAAE,EAAE,CAAA;IAC/B,IAAI,IAAI,CAAC,WAAW,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;QACpD,IAAI,CAAC,gBAAgB,CAAC,GAAG,IAAI,CAAC,WAAW,CAAA;QACzC,IAAI,CAAC,uBAAuB,CAAC,GAAG,IAAI,CAAC,WAAW,CAAA;QAChD,IAAI,CAAC,gCAAgC,CAAC;YACpC,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,WAAW,IAAI,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAA;QAChF,IAAI,CAAC,+BAA+B,CAAC;YACnC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,CAAA;QACrE,IAAI,CAAC,yBAAyB,CAAC,GAAG,IAAI,CAAA;QACtC,IAAI,CAAC,+BAA+B,CAAC,GAAG,IAAI,CAAA;QAC5C,IAAI,IAAI,CAAC,iBAAiB,KAAK,SAAS,EAAE,CAAC;YACzC,IAAI,CAAC,0BAA0B,CAAC,GAAG,IAAI,CAAC,iBAAiB,CAAA;QAC3D,CAAC;QACD,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS;YAAE,IAAI,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC,SAAS,CAAA;IAC7E,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC"}

package/dist/types/pipeline.d.ts

@@ -0,0 +1,9 @@
+export interface PipelineConfig {
+    steps?: PipelineStepRef[];
+}
+export interface PipelineStepRef {
+    id: string;
+    step: string;
+    optional?: boolean;
+}
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/types/pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../src/types/pipeline.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,EAAE,eAAe,EAAE,CAAA;CAC1B;AAED,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB"}

package/dist/types/pipeline.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pipeline.js.map

package/dist/types/pipeline.js.map

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