apps 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/chunk-MUFMJRXR.js

@@ -0,0 +1,308 @@
+// src/runtime/index.ts
+var failure = (kind, reason) => ({
+  ok: false,
+  kind,
+  reason
+});
+var errorMessage = (error) => error instanceof Error ? error.message : String(error);
+var isJsonValue = (value) => {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.every(isJsonValue);
+  if (typeof value !== "object") return false;
+  return Object.values(value).every(isJsonValue);
+};
+var standardJsonSchemaOf = (input) => "~standard" in input ? input["~standard"].jsonSchema : void 0;
+var strictify = (node) => {
+  if (typeof node !== "object" || node === null) return node;
+  if (Array.isArray(node)) return node.map(strictify);
+  const object = { ...node };
+  if (object.type === "object" && object.additionalProperties === void 0)
+    object.additionalProperties = false;
+  for (const key of ["items", "anyOf", "oneOf", "allOf"])
+    if (key in object) object[key] = strictify(object[key]);
+  for (const key of ["properties", "$defs"])
+    if (object[key] !== void 0 && typeof object[key] === "object" && object[key] !== null)
+      object[key] = Object.fromEntries(
+        Object.entries(object[key]).map(([name, value]) => [
+          name,
+          strictify(value)
+        ])
+      );
+  return object;
+};
+var compileInputSchema = (input, where) => {
+  const standard = standardJsonSchemaOf(input);
+  if ("~standard" in input && typeof standard?.input !== "function")
+    return {
+      problem: `${where}: input is a Standard Schema without the jsonSchema extension \u2014 use a library that implements it (zod 4+, effect Schema) or pass raw JSON schema`
+    };
+  try {
+    const compiled = strictify(
+      typeof standard?.input === "function" ? standard.input({ target: "draft-2020-12" }) : structuredClone(input)
+    );
+    if (typeof compiled !== "object" || compiled === null || Array.isArray(compiled) || !isJsonValue(compiled))
+      throw new Error("expected a JSON object");
+    return { value: compiled };
+  } catch (error) {
+    return {
+      problem: `${where}: input schema could not compile to JSON schema (${errorMessage(error)})`
+    };
+  }
+};
+var requirementKey = Symbol.for("executor/apps/requirement");
+var requirementSpecOf = (value) => typeof value === "object" && value !== null && requirementKey in value ? value[requirementKey] : void 0;
+var segmentOf = (file) => {
+  const name = file.slice(file.lastIndexOf("/") + 1);
+  return name.endsWith(".ts") ? name.slice(0, -3) : name;
+};
+var canonicalJson = (value) => {
+  const sortKeys = (node) => {
+    if (Array.isArray(node)) return node.map(sortKeys);
+    if (typeof node === "object" && node !== null)
+      return Object.fromEntries(
+        Object.entries(node).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortKeys(child)])
+      );
+    return node;
+  };
+  return JSON.stringify(sortKeys(value));
+};
+var collectRegistry = (registry) => {
+  const problems = registry.problems.map((problem) => problem.message);
+  const app = registry.app;
+  const claims = /* @__PURE__ */ new Map();
+  for (const [origin, registered] of registry.services) {
+    if (registered.file !== "app.ts") continue;
+    const { decl } = registered;
+    claims.set(origin, {
+      origin,
+      reach: decl.reach ?? [],
+      params: decl.params ?? {},
+      auth: decl.auth ?? {}
+    });
+  }
+  const collectRequirement = (role, requirement, where) => {
+    const spec = requirementSpecOf(requirement);
+    if (spec === void 0) {
+      problems.push(`${where}: requirement '${role}' is not a service/requirement value`);
+      return void 0;
+    }
+    const origin = spec.service.origin;
+    if (!claims.has(origin))
+      problems.push(`${where}: requirement '${role}' names ${origin}, which app.ts does not declare`);
+    if (spec.grant !== void 0 && !(spec.grant in (spec.service.auth ?? {})))
+      problems.push(
+        `${where}: requirement '${role}' pins grant '${spec.grant}', not a auth method on ${origin}`
+      );
+    return {
+      role,
+      service: origin,
+      arity: spec.arity,
+      ...spec.grant === void 0 ? {} : { grant: spec.grant },
+      ...spec.description === void 0 ? {} : { description: spec.description }
+    };
+  };
+  if (app === void 0) problems.push("app.ts must call defineApp({...})");
+  else if (typeof app.description !== "string" || app.description.trim().length === 0)
+    problems.push("app.ts: app description must not be empty");
+  for (const [file, summary] of registry.toolFiles) {
+    if (summary.definitions > 1 && summary.hasUnnamedTool)
+      problems.push(`${file}: multi-tool files must name every tool`);
+    if (registry.dynamic.has(file))
+      problems.push(`${file}: a file claims a dynamic tool set or defines tools, never both`);
+  }
+  const tools = [];
+  if (app !== void 0) {
+    for (const [name, registered] of registry.tools) {
+      const { spec, file } = registered;
+      const address = `${app.key}/${name}`;
+      if (typeof spec.description !== "string" || spec.description.trim().length === 0)
+        problems.push(`${file}: tool '${name}' description must not be empty`);
+      const requires = Object.entries(spec.requirements ?? {}).flatMap(([role, requirement]) => {
+        const collected = collectRequirement(role, requirement, address);
+        return collected === void 0 ? [] : [collected];
+      }).sort((left, right) => left.role.localeCompare(right.role));
+      const compiled = compileInputSchema(spec.input, address);
+      if ("problem" in compiled) {
+        problems.push(compiled.problem);
+        continue;
+      }
+      tools.push({
+        address,
+        name,
+        description: spec.description,
+        inputSchema: compiled.value,
+        annotations: spec.annotations ?? {},
+        requires,
+        file
+      });
+    }
+  }
+  const dynamic = [];
+  const seenSegments = /* @__PURE__ */ new Map();
+  for (const [file, registered] of registry.dynamic) {
+    const segment = segmentOf(file);
+    const where = `${file}: dynamic tool set '${segment}'`;
+    const existing = seenSegments.get(segment);
+    if (existing !== void 0) {
+      problems.push(`${where}: segment already claimed by ${existing}`);
+      continue;
+    }
+    seenSegments.set(segment, file);
+    const requires = Object.entries(registered.spec.requirements ?? {}).flatMap(([role, requirement]) => {
+      const collected = collectRequirement(role, requirement, where);
+      return collected === void 0 ? [] : [collected];
+    }).sort((left, right) => left.role.localeCompare(right.role));
+    dynamic.push({
+      segment,
+      description: registered.spec.description,
+      requires,
+      file
+    });
+  }
+  if (problems.length > 0 || app === void 0) return { problems };
+  const services = [...claims.values()].sort(
+    (left, right) => left.origin.localeCompare(right.origin)
+  );
+  const sortedTools = [...tools].sort((left, right) => left.address.localeCompare(right.address));
+  const sortedDynamic = [...dynamic].sort(
+    (left, right) => left.segment.localeCompare(right.segment)
+  );
+  const appResult = { key: app.key, label: app.label, description: app.description };
+  const manifest = {
+    app: appResult,
+    services,
+    tools: sortedTools,
+    dynamic: sortedDynamic
+  };
+  return { problems: [], manifest, canonical: canonicalJson(manifest) };
+};
+var digestOf = async (canonical) => {
+  const bytes = new Uint8Array(
+    await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(canonical))
+  );
+  return Array.from(bytes.slice(0, 8), (byte) => byte.toString(16).padStart(2, "0")).join("");
+};
+var manifestOf = async (registry) => {
+  const collected = collectRegistry(registry);
+  if (collected.problems.length > 0) return { ok: false, problems: collected.problems };
+  if (!("manifest" in collected))
+    return { ok: false, problems: ["validated registry projection unexpectedly missing"] };
+  return {
+    ok: true,
+    result: { digest: `snap:${await digestOf(collected.canonical)}`, ...collected.manifest }
+  };
+};
+var standardValidateOf = (input) => "~standard" in input && typeof input["~standard"].validate === "function" ? input["~standard"].validate : void 0;
+var parseInput = async (schema, input) => {
+  const validate = standardValidateOf(schema);
+  if (validate === void 0)
+    return { ok: false, reason: "input schema does not implement Standard Schema validate" };
+  try {
+    const result = await validate(input);
+    if (result.issues !== void 0)
+      return {
+        ok: false,
+        reason: `invalid input (${result.issues.map((issue) => issue.message).join("; ")})`
+      };
+    return { ok: true, value: result.value };
+  } catch (error) {
+    return { ok: false, reason: `input validation threw (${errorMessage(error)})` };
+  }
+};
+var splitDynamicAddress = (address) => {
+  const slash = address.indexOf("/");
+  if (slash <= 0 || slash === address.length - 1) return void 0;
+  return { segment: address.slice(0, slash), name: address.slice(slash + 1) };
+};
+var dynamicFor = (registry, segment) => {
+  for (const [file, registered] of registry.dynamic)
+    if (segmentOf(file) === segment) return registered.spec;
+  return void 0;
+};
+var discoveredSpecs = /* @__PURE__ */ new WeakMap();
+var callTool = async (registry, address, input, ctx, detail) => {
+  const dynamic = splitDynamicAddress(address);
+  if (dynamic === void 0) {
+    if (detail !== void 0)
+      return failure("handler", "a static tool takes no discovery detail");
+    const registered = registry.tools.get(address);
+    if (registered === void 0) return failure("handler", "unknown tool");
+    const parsed2 = await parseInput(registered.spec.input, input);
+    if (!parsed2.ok) return failure("input", parsed2.reason);
+    try {
+      const handler = registered.spec.handler;
+      return { ok: true, value: await handler(parsed2.value, ctx) };
+    } catch (error) {
+      return failure("handler", `handler failed (${errorMessage(error)})`);
+    }
+  }
+  if (detail === void 0)
+    return failure("handler", "a dynamic tool requires discovery detail");
+  const pair = dynamicFor(registry, dynamic.segment);
+  if (pair === void 0)
+    return failure("handler", `unknown dynamic tool set '${dynamic.segment}'`);
+  const discovered = discoveredSpecs.get(registry)?.get(dynamic.segment)?.get(dynamic.name);
+  if (discovered === void 0)
+    return failure(
+      "input",
+      `dynamic tool '${dynamic.name}' has no compiled discovery descriptor`
+    );
+  const parsed = await parseInput(discovered.input, input);
+  if (!parsed.ok) return failure("input", parsed.reason);
+  try {
+    const call = pair.call;
+    return {
+      ok: true,
+      value: await call({ name: dynamic.name, detail }, parsed.value, ctx)
+    };
+  } catch (error) {
+    return failure("handler", `dynamic call failed (${errorMessage(error)})`);
+  }
+};
+var discoverTool = async (registry, segment, ctx) => {
+  const pair = dynamicFor(registry, segment);
+  if (pair === void 0)
+    return { ok: false, reason: `unknown dynamic tool set '${segment}'` };
+  discoveredSpecs.get(registry)?.delete(segment);
+  let emitted;
+  try {
+    const discover = pair.discover;
+    emitted = await discover(ctx);
+  } catch (error) {
+    return { ok: false, reason: `discover failed (${errorMessage(error)})` };
+  }
+  const tools = [];
+  const live = /* @__PURE__ */ new Map();
+  for (const tool of emitted) {
+    if (live.has(tool.name))
+      return { ok: false, reason: `discover emitted duplicate tool '${tool.name}'` };
+    const compiled = compileInputSchema(tool.input, `${segment}/${tool.name}`);
+    if ("problem" in compiled) return { ok: false, reason: compiled.problem };
+    live.set(tool.name, tool);
+    tools.push({
+      segment,
+      name: tool.name,
+      descriptor: {
+        description: tool.description,
+        inputSchema: compiled.value,
+        annotations: {
+          ...tool.annotations?.readOnly === void 0 ? {} : { readOnly: tool.annotations.readOnly },
+          ...tool.annotations?.destructive === void 0 ? {} : { destructive: tool.annotations.destructive }
+        }
+      },
+      detail: tool.detail ?? null
+    });
+  }
+  const registryDiscoveries = discoveredSpecs.get(registry) ?? /* @__PURE__ */ new Map();
+  registryDiscoveries.set(segment, live);
+  discoveredSpecs.set(registry, registryDiscoveries);
+  return { ok: true, value: tools.sort((left, right) => left.name.localeCompare(right.name)) };
+};
+
+export {
+  compileInputSchema,
+  manifestOf,
+  callTool,
+  discoverTool
+};

package/dist/chunk-S5KFP4JQ.js

@@ -0,0 +1,20 @@
+// src/http/index.ts
+var authHeaders = (role) => {
+  switch (role.kind) {
+    case "bearer":
+    case "oauth":
+      return { authorization: `Bearer ${role.token}` };
+    case "basic":
+      return { authorization: `Basic ${base64(`${role.username}:${role.password}`)}` };
+  }
+};
+var base64 = (value) => {
+  const bytes = new TextEncoder().encode(value);
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+};
+
+export {
+  authHeaders
+};

package/dist/chunk-Y6LLTN7W.js

@@ -0,0 +1,99 @@
+import {
+  manifestOf
+} from "./chunk-MUFMJRXR.js";
+import {
+  PublishError
+} from "./chunk-B7NEUIJL.js";
+import {
+  __enterFile,
+  __leaveFile,
+  newRegistry,
+  setActiveRegistry
+} from "./chunk-A3H32P2J.js";
+
+// src/manifest/index.ts
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { Effect, FileSystem, MutableRef, Semaphore } from "effect";
+var moduleProblem = (where, error) => `${where}: failed to execute (${error instanceof Error ? error.message : String(error)})`;
+var loadPermit = Semaphore.makeUnsafe(1);
+var runNonce = MutableRef.make(0);
+var importedAppUrls = MutableRef.make(/* @__PURE__ */ new Set());
+var canonicalModuleUrl = (path, where) => FileSystem.FileSystem.pipe(
+  Effect.flatMap((fs) => fs.realPath(path)),
+  Effect.map(pathToFileURL),
+  Effect.mapError((error) => new PublishError({ problems: [moduleProblem(where, error)] }))
+);
+var importModule = (specifier, where) => Effect.tryPromise({
+  try: () => import(specifier),
+  catch: (error) => new PublishError({ problems: [moduleProblem(where, error)] })
+}).pipe(Effect.asVoid);
+var executeModule = (registry, where, load) => Effect.suspend(() => {
+  __enterFile(where);
+  return load;
+}).pipe(
+  Effect.catchTag(
+    "PublishError",
+    (error) => Effect.sync(() => {
+      registry.problems.push(...error.problems.map((message) => ({ message })));
+    })
+  )
+);
+var appEntrySpecifier = (appUrl, nonce) => {
+  const seen = MutableRef.get(importedAppUrls);
+  if (!seen.has(appUrl.href)) {
+    MutableRef.set(importedAppUrls, /* @__PURE__ */ new Set([...seen, appUrl.href]));
+    return appUrl.href;
+  }
+  return `${fileURLToPath(appUrl)}?m=${nonce}`;
+};
+var executeModules = (appDir, files) => loadPermit.withPermit(
+  Effect.acquireUseRelease(
+    Effect.sync(() => {
+      const registry = newRegistry();
+      return { registry, previous: setActiveRegistry(registry) };
+    }),
+    ({ registry }) => Effect.gen(function* () {
+      const nonce = MutableRef.incrementAndGet(runNonce);
+      yield* executeModule(
+        registry,
+        "app.ts",
+        canonicalModuleUrl(`${appDir}/app.ts`, "app.ts").pipe(
+          Effect.flatMap((appUrl) => importModule(appEntrySpecifier(appUrl, nonce), "app.ts"))
+        )
+      );
+      for (const file of files) {
+        const where = `tools/${file}`;
+        yield* executeModule(
+          registry,
+          where,
+          canonicalModuleUrl(`${appDir}/tools/${file}`, where).pipe(
+            Effect.flatMap((url) => importModule(`${fileURLToPath(url)}?m=${nonce}`, where))
+          )
+        );
+      }
+      return registry;
+    }),
+    ({ previous }) => Effect.sync(() => {
+      __leaveFile();
+      setActiveRegistry(previous);
+    })
+  )
+);
+var toolFiles = (appDir) => FileSystem.FileSystem.pipe(
+  Effect.flatMap((fs) => fs.readDirectory(`${appDir}/tools`)),
+  Effect.mapError((error) => new PublishError({ problems: [`tools/: ${error.message}`] })),
+  Effect.map((entries) => entries.filter((file) => file.endsWith(".ts")).sort())
+);
+var loadApp = (appDir) => Effect.gen(function* () {
+  const files = yield* toolFiles(appDir);
+  const registry = yield* executeModules(appDir, files);
+  const outcome = yield* Effect.promise(() => manifestOf(registry));
+  if (!outcome.ok) return yield* new PublishError({ problems: outcome.problems });
+  return { registry, result: outcome.result };
+});
+var manifest = (appDir) => Effect.map(loadApp(appDir), ({ result }) => result);
+
+export {
+  loadApp,
+  manifest
+};

package/dist/chunk-YUZ4TXOY.js

@@ -0,0 +1,27 @@
+import {
+  defineDynamicTools
+} from "./chunk-A3H32P2J.js";
+
+// src/mcp/client.ts
+var mcpDiscover = async (_endpoint, _ctx, _auth, _operations) => {
+  throw new Error("mcp client not built yet");
+};
+var mcpCall = async (_endpoint, _tool, _input, _ctx, _auth) => {
+  throw new Error("mcp client not built yet");
+};
+
+// src/mcp/index.ts
+function fromMCP(endpoint, options) {
+  const auth = options?.auth;
+  const operations = options?.operations;
+  return defineDynamicTools({
+    description: `Tools served by the MCP server at ${endpoint}.`,
+    ...options?.requirements === void 0 ? {} : { requirements: options.requirements },
+    discover: (ctx) => mcpDiscover(endpoint, ctx, auth, operations),
+    call: (tool, input, ctx) => mcpCall(endpoint, tool.name, input, ctx, auth)
+  });
+}
+
+export {
+  fromMCP
+};

package/dist/http/index.d.ts

@@ -0,0 +1,9 @@
+/** HTTP credential placement helpers for kind-bearing connected roles. */
+import type { RoleMaterial } from "../authoring/index";
+export type HttpSpendableRole = Extract<RoleMaterial, {
+    kind: "bearer" | "oauth" | "basic";
+}>;
+/** Build the protocol-defined Authorization header for a connected role. */
+export declare const authHeaders: (role: HttpSpendableRole) => {
+    readonly authorization: string;
+};

package/dist/http/index.js

@@ -0,0 +1,6 @@
+import {
+  authHeaders
+} from "../chunk-S5KFP4JQ.js";
+export {
+  authHeaders
+};

package/dist/index.d.ts

@@ -1,9 +1,4 @@
-/**
- * The authoring surface: what app code imports. Pure and synchronous —
- * no effect dependency, no node builtins — so authored files run
- * unmodified in any execution environment, including sandboxed workers.
- *
- * Host-side machinery lives behind subpaths: "apps/manifest" loads and
- * validates authored sources, "apps/runner" executes them.
- */
 export * from "./authoring/index";
+export * from "./http/index";
+export * from "./mcp/index";
+export * from "./openapi/index";

package/dist/index.js

@@ -1,23 +1,45 @@
+import {
+  fromOpenAPI
+} from "./chunk-F7GZYEAC.js";
+import {
+  authHeaders
+} from "./chunk-S5KFP4JQ.js";
+import {
+  fromMCP
+} from "./chunk-YUZ4TXOY.js";
 import {
   __enterFile,
   __leaveFile,
+  basic,
+  bearer,
   defineApp,
+  defineDynamicTools,
   defineTool,
+  dynamicSpecOf,
   newRegistry,
   oauth,
+  recordAuthoringProblem,
   requirementSpecOf,
   secrets,
   service,
   setActiveRegistry,
   toolSpecOf
-} from "./chunk-LWKQDDLZ.js";
+} from "./chunk-A3H32P2J.js";
 export {
   __enterFile,
   __leaveFile,
+  authHeaders,
+  basic,
+  bearer,
   defineApp,
+  defineDynamicTools,
   defineTool,
+  dynamicSpecOf,
+  fromMCP,
+  fromOpenAPI,
   newRegistry,
   oauth,
+  recordAuthoringProblem,
   requirementSpecOf,
   secrets,
   service,

package/dist/manifest/contract.d.ts

@@ -32,6 +32,13 @@ export interface ManifestTool {
     readonly requires: readonly CollectedRequirement[];
     readonly file: string;
 }
+/** A dynamic address segment projected without endpoint or specification data. */
+export interface ManifestDynamic {
+    readonly segment: string;
+    readonly description: string;
+    readonly requires: readonly CollectedRequirement[];
+    readonly file: string;
+}
 /** The deterministic public description of an executor app. */
 export interface AppManifestResult {
     readonly digest: string;
@@ -42,6 +49,7 @@ export interface AppManifestResult {
     };
     readonly services: readonly CollectedClaim[];
     readonly tools: readonly ManifestTool[];
+    readonly dynamic: readonly ManifestDynamic[];
 }
 declare const PublishError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "PublishError";

package/dist/manifest/index.d.ts

@@ -1,9 +1,11 @@
 /**
- * Manifest: execute an authored app folder, read its registry, validate
- * every claim, and emit the deterministic publish manifest. Defines run
- * without user context; platform services begin at this boundary.
+ * Manifest: execute an authored app folder and project its registry.
+ * This module owns exactly what differs on a host with a filesystem —
+ * finding and importing authored modules. Everything after the modules
+ * load (validation, canonicalization, digesting) is the shared
+ * execution core in ../runtime; sandboxed guests run that same core.
  */
-import { Crypto, Effect, FileSystem } from "effect";
+import { Effect, FileSystem } from "effect";
 import { type Registry } from "../authoring/index";
 import { PublishError, type AppManifestResult } from "./contract";
 export * from "./contract";
@@ -13,6 +15,6 @@ export interface LoadedApp {
     readonly result: AppManifestResult;
 }
 /** Loads an app once and returns both its live registry and manifest. @internal */
-export declare const loadApp: (appDir: string) => Effect.Effect<LoadedApp, PublishError, Crypto.Crypto | FileSystem.FileSystem>;
+export declare const loadApp: (appDir: string) => Effect.Effect<LoadedApp, PublishError, FileSystem.FileSystem>;
 /** Executes an app and returns its deterministic publish manifest. */
-export declare const manifest: (appDir: string) => Effect.Effect<AppManifestResult, PublishError, Crypto.Crypto | FileSystem.FileSystem>;
+export declare const manifest: (appDir: string) => Effect.Effect<AppManifestResult, PublishError, FileSystem.FileSystem>;

package/dist/manifest/index.js

@@ -1,13 +1,13 @@
 import {
   loadApp,
   manifest
-} from "../chunk-J5AVXTHA.js";
-import "../chunk-LWKQDDLZ.js";
+} from "../chunk-Y6LLTN7W.js";
+import "../chunk-MUFMJRXR.js";
 import {
   JsonSchemaObject,
   PublishError
 } from "../chunk-B7NEUIJL.js";
-import "../chunk-RZA7AXBK.js";
+import "../chunk-A3H32P2J.js";
 export {
   JsonSchemaObject,
   PublishError,

package/dist/mcp/client.d.ts

@@ -0,0 +1,9 @@
+/** Stub-contract MCP client used by the fromMCP dynamic pair. */
+import type { AuthComposeFn, DiscoveredToolSpec, OperationSelection } from "../authoring/index";
+/** Normalize authored placement, or apply MCP's bearer default. */
+export declare const composePlacement: (auth: AuthComposeFn<never> | undefined, ctx: unknown) => {
+    headers: Headers;
+    searchParams: URLSearchParams;
+};
+export declare const mcpDiscover: (_endpoint: string, _ctx: unknown, _auth: AuthComposeFn<never> | undefined, _operations: OperationSelection | undefined) => Promise<readonly DiscoveredToolSpec[]>;
+export declare const mcpCall: (_endpoint: string, _tool: string, _input: unknown, _ctx: unknown, _auth: AuthComposeFn<never> | undefined) => Promise<unknown>;

package/dist/mcp/index.d.ts

@@ -0,0 +1,11 @@
+/** fromMCP sugar over the authored dynamic-tools primitive. */
+import { type AuthComposeFn, type DynamicToolSet, type OperationSelection, type Requirement } from "../authoring/index";
+export type FromMCPOptions<Reqs extends Readonly<Record<string, Requirement>>> = {
+    readonly requirements: Reqs;
+    readonly auth?: AuthComposeFn<NoInfer<Reqs>>;
+    readonly operations?: OperationSelection;
+};
+export declare function fromMCP<const Reqs extends Readonly<Record<string, Requirement>>>(endpoint: string, options: FromMCPOptions<Reqs>): DynamicToolSet;
+export declare function fromMCP(endpoint: string, options?: {
+    readonly operations?: OperationSelection;
+}): DynamicToolSet;

package/dist/mcp/index.js

@@ -0,0 +1,7 @@
+import {
+  fromMCP
+} from "../chunk-YUZ4TXOY.js";
+import "../chunk-A3H32P2J.js";
+export {
+  fromMCP
+};

package/dist/openapi/index.d.ts

@@ -0,0 +1,14 @@
+/** fromOpenAPI sugar over the authored dynamic-tools primitive. */
+import { type AuthComposeFn, type DynamicToolSet, type OperationSelection, type Requirement, type RequiresAuthCompose } from "../authoring/index";
+export type FromOpenAPIOptions<Reqs extends Readonly<Record<string, Requirement>>> = {
+    readonly requirements: Reqs;
+    readonly auth?: AuthComposeFn<NoInfer<Reqs>>;
+    readonly operations?: OperationSelection;
+} & (RequiresAuthCompose<Reqs> extends true ? {
+    readonly auth: AuthComposeFn<NoInfer<Reqs>>;
+} : unknown);
+export type OpenAPIDocumentInput = string | Readonly<Record<string, unknown>>;
+export declare function fromOpenAPI<const Reqs extends Readonly<Record<string, Requirement>>>(spec: OpenAPIDocumentInput, options: FromOpenAPIOptions<Reqs>): DynamicToolSet;
+export declare function fromOpenAPI(spec: OpenAPIDocumentInput, options?: {
+    readonly operations?: OperationSelection;
+}): DynamicToolSet;

package/dist/openapi/index.js

@@ -0,0 +1,7 @@
+import {
+  fromOpenAPI
+} from "../chunk-F7GZYEAC.js";
+import "../chunk-A3H32P2J.js";
+export {
+  fromOpenAPI
+};

package/dist/openapi/mapper.d.ts

@@ -0,0 +1,7 @@
+/** Stub-contract OpenAPI discovery and call mapper. */
+import type { AuthComposeFn, DiscoveredToolSpec, OperationSelection } from "../authoring/index";
+export declare const openapiDiscover: (_spec: string | Readonly<Record<string, unknown>>, _ctx: unknown, _auth: AuthComposeFn<never> | undefined, _operations: OperationSelection | undefined) => Promise<readonly DiscoveredToolSpec[]>;
+export declare const openapiCall: (_tool: {
+    readonly name: string;
+    readonly detail: unknown;
+}, _input: unknown, _ctx: unknown, _auth: AuthComposeFn<never> | undefined) => Promise<unknown>;