apps 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/authoring/index.d.ts

@@ -3,6 +3,18 @@
  * Authored modules record plain claims without I/O or user context; the
  * manifest loader owns execution, validation, and effects.
  */
+/** A single opaque credential with RFC 6750 bearer semantics. */
+export interface BearerMethod {
+    readonly kind: "bearer";
+    readonly label: string;
+    readonly help?: string;
+}
+/** An RFC 7617 username/password pair. */
+export interface BasicMethod {
+    readonly kind: "basic";
+    readonly label: string;
+    readonly help?: string;
+}
 export interface SecretsMethod<F extends Readonly<Record<string, SecretField>> = Readonly<Record<string, SecretField>>> {
     readonly kind: "secrets";
     readonly label: string;
@@ -17,7 +29,7 @@ export interface SecretField {
     readonly secret: boolean;
 }
 /**
- * An oauth auth method is a secrets-shaped auth method with acquisition strategies
+ * An oauth auth method is a bearer method with acquisition strategies
  * layered on: the material contract is always {token, refresh_token?,
  * expires_at?}, and the host fills it by the best strategy it can offer
  * — authorization-code ceremony, device-code ceremony, or paste. Paste
@@ -41,7 +53,15 @@ export interface OAuthMethod {
      * (audience-bound tokens, DPoP). Stated, never inferred. */
     readonly paste?: false;
 }
-export type AuthMethod = SecretsMethod | OAuthMethod;
+export type AuthMethod = BearerMethod | BasicMethod | SecretsMethod | OAuthMethod;
+export declare const bearer: (opts: {
+    readonly label: string;
+    readonly help?: string;
+}) => BearerMethod;
+export declare const basic: (opts: {
+    readonly label: string;
+    readonly help?: string;
+}) => BasicMethod;
 export declare const secrets: <const F extends Readonly<Record<string, SecretField>>>(opts: {
     readonly label: string;
     /** Markdown shown under this auth method on the connect page, for example:
@@ -82,55 +102,195 @@ export interface RequirementSpec {
     readonly description?: string;
 }
 declare const RequirementKey: unique symbol;
+declare const ServiceDeclKey: unique symbol;
+declare const RequirementPhantom: unique symbol;
+/** Requirement arity, tracked at the type level so handler contexts
+ * know whether a role arrives as one entry, maybe-one, or a list. */
+export type RequirementArity = "one" | "optional" | "many";
 /**
  * A requirement value in a tool's `requirements` record. A Service IS
  * a requirement (bare value = arity "one"); .optional()/.array()
  * return terminal Requirements so nonsense chains do not typecheck.
+ * The phantom property is never assigned — it exists so auth-compose
+ * callbacks and handler contexts can recover the service's grants, an
+ * auth-door pin, and the arity at the type level.
  */
-export interface Requirement<D extends ServiceDecl = ServiceDecl> {
+export interface Requirement<D extends ServiceDecl = ServiceDecl, G extends string | undefined = string | undefined, A extends RequirementArity = RequirementArity> {
     readonly [RequirementKey]: RequirementSpec;
-    describe(text: string): Requirement<D>;
-}
-export interface Service<D extends ServiceDecl = ServiceDecl> extends Requirement<D> {
-    readonly decl: D;
-    optional(): Requirement<D>;
-    array(): Requirement<D>;
-    /** Pin one auth method: this tool supports only the named grant. */
-    grant(name: keyof NonNullable<D["auth"]> & string): Service<D>;
+    readonly [RequirementPhantom]?: {
+        readonly decl: D;
+        readonly pinned: G;
+        readonly arity: A;
+    };
+    describe(text: string): Requirement<D, G, A>;
+}
+/**
+ * A grant-pinned requirement: what `service.auth.<name>` returns. A
+ * deliberately narrower type than Service — it can shape arity and
+ * describe itself, but carries no `auth` (pinning twice is nonsense)
+ * and no declaration access. Pinning is property access because the
+ * grants are static facts of the declaration: `github.auth.pat`
+ * autocompletes and a wrong name fails compilation.
+ */
+export interface PinnedRequirement<D extends ServiceDecl = ServiceDecl, N extends string = string> extends Requirement<D, N, "one"> {
+    optional(): Requirement<D, N, "optional">;
+    array(): Requirement<D, N, "many">;
+    describe(text: string): PinnedRequirement<D, N>;
+}
+/** The grant-pinned doors of a service, keyed by declared auth method. */
+export type ServiceAuth<D extends ServiceDecl> = {
+    readonly [N in keyof NonNullable<D["auth"]> & string]: PinnedRequirement<D, N>;
+};
+export interface Service<D extends ServiceDecl = ServiceDecl> extends Requirement<D, undefined, "one"> {
+    /** Symbol-keyed so author IntelliSense shows only authoring verbs;
+     * the declaration is plumbing the manifest reads at collection. */
+    readonly [ServiceDeclKey]: D;
+    /** Pin one auth method: `github.auth.pat` is this tool supporting
+     * only that grant. */
+    readonly auth: ServiceAuth<D>;
+    optional(): Requirement<D, undefined, "optional">;
+    array(): Requirement<D, undefined, "many">;
     describe(text: string): Service<D>;
 }
 /** A publish-time authoring problem accumulated without interrupting defines. */
 export interface Problem {
     readonly message: string;
 }
-/**
- * A dynamic tool-set claim: tools discovered from a live surface (an
- * MCP server's tool list, an OpenAPI document) rather than authored one
- * file at a time. The claim is recorded at publish time; discovery runs
- * later, per connection — an app with zero static tools and one claim
- * saves green, and listing never blocks on an upstream.
- */
-export type DynamicClaimSpec = {
-    readonly kind: "mcp";
-    readonly requirement: RequirementSpec;
-    /** MCP endpoint URL. Absent = the service origin at its root path. */
-    readonly endpoint?: string;
+/** One connected role, discriminated by the declared auth method kind. */
+export type AuthRoleEntry<D extends ServiceDecl> = {
+    [N in keyof NonNullable<D["auth"]> & string]: NonNullable<D["auth"]>[N] extends SecretsMethod<infer F> ? {
+        readonly grant: N;
+        readonly kind: "secrets";
+        readonly secrets: {
+            readonly [K in keyof F & string]: string;
+        };
+    } : NonNullable<D["auth"]>[N] extends BasicMethod ? {
+        readonly grant: N;
+        readonly kind: "basic";
+        readonly username: string;
+        readonly password: string;
+    } : {
+        readonly grant: N;
+        readonly kind: "bearer" | "oauth";
+        readonly token: string;
+    };
+}[keyof NonNullable<D["auth"]> & string];
+/** Kind-discriminated credential material accepted by surface helpers. */
+export type RoleMaterial = {
+    readonly kind: "bearer" | "oauth";
+    readonly token: string;
+} | {
+    readonly kind: "basic";
+    readonly username: string;
+    readonly password: string;
 } | {
-    readonly kind: "openapi";
-    readonly requirement: RequirementSpec;
-    /** OpenAPI document: an absolute URL or an app-relative path. */
-    readonly spec: string;
+    readonly kind: "secrets";
+    readonly secrets: Readonly<Record<string, string>>;
+};
+/** Recover the connected role type produced by a service requirement. */
+export type RoleOf<S, G extends string | undefined = undefined> = S extends Requirement<infer D, infer Pin> ? [G] extends [string] ? Extract<AuthRoleEntry<D>, {
+    grant: G;
+}> : Pin extends string ? Extract<AuthRoleEntry<D>, {
+    grant: Pin;
+}> : AuthRoleEntry<D> : never;
+/** Role record received by an authored authentication placement callback. */
+export type AuthRoles<Reqs extends Readonly<Record<string, Requirement>>> = {
+    readonly [K in keyof Reqs]: NonNullable<Reqs[K][typeof RequirementPhantom]> extends {
+        readonly decl: infer D extends ServiceDecl;
+        readonly pinned: infer G;
+    } ? G extends string ? Extract<AuthRoleEntry<D>, {
+        grant: G;
+    }> : AuthRoleEntry<D> : never;
 };
+/** Request placement returned by an authored dynamic auth callback. */
+export interface AuthPlacement {
+    readonly headers?: HeadersInit;
+    readonly searchParams?: URLSearchParams | Readonly<Record<string, string>>;
+}
+export type AuthComposeFn<Reqs extends Readonly<Record<string, Requirement>> = never> = (roles: AuthRoles<Reqs>) => AuthPlacement | undefined | void;
+export type HasSecretsGrant<D extends ServiceDecl> = true extends (NonNullable<D["auth"]>[keyof NonNullable<D["auth"]>] extends infer M ? M extends SecretsMethod ? true : false : never) ? true : false;
+/** Whether an OpenAPI wrapper must state credential placement explicitly. */
+export type RequiresAuthCompose<Reqs extends Readonly<Record<string, Requirement>>> = true extends {
+    [K in keyof Reqs]: NonNullable<Reqs[K][typeof RequirementPhantom]> extends {
+        readonly decl: infer D extends ServiceDecl;
+        readonly pinned: infer G;
+    } ? G extends keyof NonNullable<D["auth"]> & string ? NonNullable<D["auth"]>[G] extends SecretsMethod ? true : false : HasSecretsGrant<D> : never;
+}[keyof Reqs] ? true : false;
+/** Record a wrapper-specific publish problem on the active authored file. @internal */
+export declare const recordAuthoringProblem: (message: string) => void;
+/** Operation curation for a dynamic tool set. Exactly one of allow/block. */
+export type OperationSelection = {
+    readonly allow: readonly string[];
+    readonly block?: undefined;
+} | {
+    readonly block: readonly string[];
+    readonly allow?: undefined;
+};
+/** One tool emitted by a dynamic discovery pass. */
+export interface DiscoveredToolSpec {
+    readonly name: string;
+    readonly description: string;
+    readonly input: SchemaLike;
+    readonly annotations?: ToolAnnotations;
+    readonly detail?: unknown;
+}
+/**
+ * The generic authored shape of a dynamic pair: ctx is inferred from
+ * the requirements record exactly as for static tools. Discovered
+ * inputs are runtime data (the schema arrives from the upstream at
+ * discover time), so `call`'s input is honestly `unknown` — the
+ * runtime validates against the discovered descriptor before calling.
+ */
+export interface DynamicToolsDecl<Reqs extends Readonly<Record<string, Requirement>> | undefined = Readonly<Record<string, Requirement>> | undefined> {
+    readonly description: string;
+    readonly requirements?: Reqs;
+    discover(args: {
+        readonly ctx: HandlerCtx<Reqs>;
+    }): Promise<readonly DiscoveredToolSpec[]>;
+    call(args: {
+        readonly tool: {
+            readonly name: string;
+            readonly detail: unknown;
+        };
+        readonly input: unknown;
+        readonly ctx: HandlerCtx<Reqs>;
+    }): Promise<unknown>;
+}
+/**
+ * The erased registry row of a dynamic pair — same storage boundary
+ * as ToolSpec. App code: runs where handlers run (in-process locally,
+ * inside the isolate on workerd) and places credentials itself from
+ * ctx, like any handler. `discover` interrogates the tool source;
+ * `call` executes one discovered tool from the identity and detail
+ * discover emitted.
+ */
+export interface DynamicToolsSpec {
+    readonly description: string;
+    readonly requirements?: Readonly<Record<string, Requirement>>;
+    discover(args: never): Promise<readonly DiscoveredToolSpec[]>;
+    call(args: never): Promise<unknown>;
+}
 declare const DynamicKey: unique symbol;
-/** The value fromMCP/fromOpenAPI return: an opaque claim handle a tool
- * file default-exports. The spec is undefined when the claim was
+/** The value defineDynamicTools returns: an opaque handle a tool file
+ * default-exports. The spec is undefined when the definition was
  * invalid (a problem was recorded instead). */
 export interface DynamicToolSet {
-    readonly [DynamicKey]: DynamicClaimSpec | undefined;
+    readonly [DynamicKey]: DynamicToolsSpec | undefined;
 }
-/** A registered dynamic claim and its source attribution. @internal */
-export interface RegisteredDynamic {
-    readonly spec: DynamicClaimSpec;
+/** Reads a dynamic spec from a tool file's default export. @internal */
+export declare const dynamicSpecOf: (value: unknown) => DynamicToolsSpec | undefined;
+/**
+ * The dynamic-tools primitive: an author-written discover/call pair
+ * whose tool list is interrogated at runtime, per connection, instead
+ * of authored one file at a time. The file's name becomes the address
+ * segment (appKey/<stem>/<toolName>); tools land in the catalog after
+ * discovery and never block a save. fromMCP/fromOpenAPI are shipped
+ * pairs over this same primitive.
+ */
+export declare const defineDynamicTools: <const Reqs extends Readonly<Record<string, Requirement>> | undefined = undefined>(decl: DynamicToolsDecl<Reqs>) => DynamicToolSet;
+/** A registered dynamic tool set and its source attribution. @internal */
+export interface DynamicRegistration {
+    readonly spec: DynamicToolsSpec;
     readonly file: string;
 }
 /** A registered service declaration and its source attribution. @internal */
@@ -148,7 +308,7 @@ export interface Registry {
     app: AppManifest | undefined;
     readonly services: Map<string, RegisteredService>;
     readonly tools: Map<string, RegisteredTool>;
-    readonly dynamic: Map<string, RegisteredDynamic>;
+    readonly dynamic: Map<string, DynamicRegistration>;
     readonly problems: Problem[];
     readonly toolFiles: Map<string, {
         definitions: number;
@@ -178,27 +338,84 @@ export declare const defineApp: (manifest: {
 }) => AppManifest;
 /** Any Standard Schema (zod preferred) or a raw JSON-schema object. */
 export type SchemaLike = object;
+/**
+ * The validated value a Standard Schema produces, recovered from its
+ * phantom types (zod 4 and effect Schema both publish them). A raw
+ * JSON-schema object carries no phantom, so its input is `unknown` —
+ * stated weakness, not silent weakness.
+ */
+export type InferSchema<S> = S extends {
+    readonly "~standard": {
+        readonly types?: infer T;
+    };
+} ? NonNullable<T> extends {
+    readonly output: infer O;
+} ? O : unknown : unknown;
+/**
+ * The capability a handler receives for one connected requirement
+ * role: the grant's kind-discriminated material (narrowed by any
+ * auth-door pin) plus the spending fetch. Arity shapes the value —
+ * `.optional()` may be absent, `.array()` is every connected account.
+ */
+export type HandlerRole<R> = R extends Requirement<infer D, infer G, infer A> ? [A] extends ["many"] ? ReadonlyArray<HandlerRoleEntry<D, G>> : [A] extends ["optional"] ? HandlerRoleEntry<D, G> | undefined : HandlerRoleEntry<D, G> : never;
+/** One connected role entry: declared-auth material + capability fetch. */
+export type HandlerRoleEntry<D extends ServiceDecl, G extends string | undefined> = ([G] extends [string] ? Extract<AuthRoleEntry<D>, {
+    grant: G;
+}> : AuthRoleEntry<D>) & {
+    fetch(path: string, init?: RequestInit): Promise<Response>;
+};
+/** The ctx record a handler receives, keyed by requirement role. */
+export type HandlerCtx<Reqs> = [Reqs] extends [Readonly<Record<string, Requirement>>] ? {
+    readonly [K in keyof Reqs]: HandlerRole<Reqs[K]>;
+} : Readonly<Record<never, never>>;
 export interface ToolAnnotations {
     readonly readOnly?: boolean;
     readonly destructive?: boolean;
     /** Facts, not flow: shortfall surfaces as the scope challenge. */
     readonly scopes?: readonly string[];
 }
-export interface ToolSpec {
+/**
+ * The generic authored shape: input/ctx/output are all inferred — the
+ * handler's input from the Standard Schema, ctx from the requirements
+ * record (grants, pins, arity), and the return type checked against
+ * the output schema when one is stated. The handler takes ONE
+ * destructurable argument so unused halves never demand an underscore:
+ * `handler: async ({ input }) => ...` / `async ({ ctx }) => ...`.
+ */
+export interface ToolDecl<Input extends SchemaLike = SchemaLike, Reqs extends Readonly<Record<string, Requirement>> | undefined = Readonly<Record<string, Requirement>> | undefined, Output extends SchemaLike | undefined = SchemaLike | undefined> {
     /** Address segment. Single-tool files may omit it (filename). */
+    readonly name?: string;
+    readonly description: string;
+    readonly requirements?: Reqs;
+    readonly input: Input;
+    readonly output?: Output;
+    readonly annotations?: ToolAnnotations;
+    handler(args: {
+        readonly input: InferSchema<Input>;
+        readonly ctx: HandlerCtx<Reqs>;
+    }): Promise<Output extends SchemaLike ? InferSchema<Output> : unknown>;
+}
+/**
+ * The erased registry row. Registration drops the generics — storage
+ * is untyped by design, the same boundary every schema library draws
+ * between its typed builders and its runtime representation. The
+ * runtime re-establishes safety by validating input before the
+ * handler runs and shaping ctx from resolved connections.
+ */
+export interface ToolSpec {
     readonly name?: string;
     readonly description: string;
     readonly requirements?: Readonly<Record<string, Requirement>>;
     readonly input: SchemaLike;
     readonly output?: SchemaLike;
     readonly annotations?: ToolAnnotations;
-    handler(input: never, ctx: never): Promise<unknown>;
+    handler(args: never): Promise<unknown>;
 }
 declare const ToolKey: unique symbol;
 export interface Tool {
     readonly [ToolKey]: ToolSpec;
 }
-export declare const defineTool: (spec: ToolSpec) => Tool;
+export declare const defineTool: <const Input extends SchemaLike, const Reqs extends Readonly<Record<string, Requirement>> | undefined = undefined, const Output extends SchemaLike | undefined = undefined>(decl: ToolDecl<Input, Reqs, Output>) => Tool;
 export declare const toolSpecOf: (value: unknown) => ToolSpec | undefined;
 /** A tool file's default export. */
 export type ToolExport = Tool | ReadonlyArray<Tool>;

package/dist/authoring/index.js

@@ -1,23 +1,33 @@
 import {
   __enterFile,
   __leaveFile,
+  basic,
+  bearer,
   defineApp,
+  defineDynamicTools,
   defineTool,
+  dynamicSpecOf,
   newRegistry,
   oauth,
+  recordAuthoringProblem,
   requirementSpecOf,
   secrets,
   service,
   setActiveRegistry,
   toolSpecOf
-} from "../chunk-LWKQDDLZ.js";
+} from "../chunk-535V5K64.js";
 export {
   __enterFile,
   __leaveFile,
+  basic,
+  bearer,
   defineApp,
+  defineDynamicTools,
   defineTool,
+  dynamicSpecOf,
   newRegistry,
   oauth,
+  recordAuthoringProblem,
   requirementSpecOf,
   secrets,
   service,

package/dist/{chunk-OGCPVWAZ.js → chunk-2DVKSPQH.js}

@@ -1,5 +1,9 @@
 // src/runtime/index.ts
-var failure = (reason) => ({ ok: false, reason });
+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;
@@ -48,6 +52,10 @@ var compileInputSchema = (input, where) => {
 };
 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);
@@ -100,6 +108,8 @@ var collectRegistry = (registry) => {
   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) {
@@ -128,13 +138,43 @@ var collectRegistry = (registry) => {
       });
     }
   }
+  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 };
+  const manifest = {
+    app: appResult,
+    services,
+    tools: sortedTools,
+    dynamic: sortedDynamic
+  };
   return { problems: [], manifest, canonical: canonicalJson(manifest) };
 };
 var digestOf = async (canonical) => {
@@ -154,8 +194,8 @@ var manifestOf = async (registry) => {
   };
 };
 var standardValidateOf = (input) => "~standard" in input && typeof input["~standard"].validate === "function" ? input["~standard"].validate : void 0;
-var parseInput = async (spec, input) => {
-  const validate = standardValidateOf(spec.input);
+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 {
@@ -170,21 +210,102 @@ var parseInput = async (spec, input) => {
     return { ok: false, reason: `input validation threw (${errorMessage(error)})` };
   }
 };
-var callTool = async (registry, name, input, ctx) => {
-  const registered = registry.tools.get(name);
-  if (registered === void 0) return failure("unknown tool");
-  const parsed = await parseInput(registered.spec, input);
-  if (!parsed.ok) return parsed;
+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({ input: 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 handler = registered.spec.handler;
-    return { ok: true, value: await handler(parsed.value, ctx) };
+    const call = pair.call;
+    return {
+      ok: true,
+      value: await call({
+        tool: { name: dynamic.name, detail },
+        input: 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 failure(`handler failed (${errorMessage(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)) };
 };
-var discoverTool = async (_registry, _name, _binding) => failure("no dynamic tools yet");
 
 export {
+  compileInputSchema,
   manifestOf,
   callTool,
   discoverTool

package/dist/{chunk-NFLNA2SC.js → chunk-4OZFMCTT.js}

@@ -5,7 +5,13 @@ var CallError = class extends Data.TaggedError("CallError") {
     return `${this.target}: ${this.reason}`;
   }
 };
+var DiscoverError = class extends Data.TaggedError("DiscoverError") {
+  get message() {
+    return `${this.segment}: ${this.reason}`;
+  }
+};
 
 export {
-  CallError
+  CallError,
+  DiscoverError
 };