apps 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/{chunk-OGCPVWAZ.js → chunk-MUFMJRXR.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,98 @@ 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(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({ 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 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-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-646MS7DD.js → chunk-Y6LLTN7W.js}

@@ -1,15 +1,15 @@
 import {
-  __enterFile,
-  __leaveFile,
-  newRegistry,
-  setActiveRegistry
-} from "./chunk-LWKQDDLZ.js";
+  manifestOf
+} from "./chunk-MUFMJRXR.js";
 import {
   PublishError
 } from "./chunk-B7NEUIJL.js";
 import {
-  manifestOf
-} from "./chunk-OGCPVWAZ.js";
+  __enterFile,
+  __leaveFile,
+  newRegistry,
+  setActiveRegistry
+} from "./chunk-A3H32P2J.js";
 
 // src/manifest/index.ts
 import { fileURLToPath, pathToFileURL } from "node:url";

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 +1,4 @@
 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.js

@@ -1,13 +1,13 @@
 import {
   loadApp,
   manifest
-} from "../chunk-646MS7DD.js";
-import "../chunk-LWKQDDLZ.js";
+} from "../chunk-Y6LLTN7W.js";
+import "../chunk-MUFMJRXR.js";
 import {
   JsonSchemaObject,
   PublishError
 } from "../chunk-B7NEUIJL.js";
-import "../chunk-OGCPVWAZ.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>;

package/dist/runner/index.js

@@ -1,15 +1,16 @@
 import {
   loadApp
-} from "../chunk-646MS7DD.js";
-import "../chunk-LWKQDDLZ.js";
-import "../chunk-B7NEUIJL.js";
-import {
-  CallError
-} from "../chunk-NFLNA2SC.js";
+} from "../chunk-Y6LLTN7W.js";
 import {
   callTool,
   discoverTool
-} from "../chunk-OGCPVWAZ.js";
+} from "../chunk-MUFMJRXR.js";
+import "../chunk-B7NEUIJL.js";
+import {
+  CallError,
+  DiscoverError
+} from "../chunk-4OZFMCTT.js";
+import "../chunk-A3H32P2J.js";
 
 // src/runner/index.ts
 import { Effect } from "effect";
@@ -28,25 +29,38 @@ var localRunner = (appDir) => {
   const registryFor = (target) => loaded().pipe(
     Effect.map(({ registry }) => registry),
     Effect.mapError(
-      (error) => new CallError({ target, reason: `app failed to load (${error.message})` })
+      (error) => new CallError({
+        target,
+        kind: "handler",
+        reason: `app failed to load (${error.message})`
+      })
     )
   );
-  const settle = (target, outcome) => outcome.ok ? Effect.succeed(outcome.value) : Effect.fail(new CallError({ target, reason: outcome.reason }));
+  const settle = (target, outcome) => outcome.ok ? Effect.succeed(outcome.value) : Effect.fail(new CallError({
+    target,
+    kind: outcome.kind,
+    reason: outcome.reason
+  }));
+  const settleDiscovery = (segment, outcome) => outcome.ok ? Effect.succeed(outcome.value) : Effect.fail(new DiscoverError({ segment, reason: outcome.reason }));
   return {
     manifest: () => Effect.map(loaded(), ({ result }) => result),
-    call: (name, input, ctx) => registryFor(name).pipe(
-      Effect.flatMap((registry) => Effect.promise(() => callTool(registry, name, input, ctx))),
-      Effect.flatMap((outcome) => settle(name, outcome))
+    call: (address, input, ctx, detail) => registryFor(address).pipe(
+      Effect.flatMap(
+        (registry) => Effect.promise(() => callTool(registry, address, input, ctx, detail))
+      ),
+      Effect.flatMap((outcome) => settle(address, outcome))
     ),
-    discover: (name, binding) => registryFor(name).pipe(
+    discover: (segment, ctx) => registryFor(segment).pipe(
+      Effect.mapError((error) => new DiscoverError({ segment, reason: error.reason })),
       Effect.flatMap(
-        (registry) => Effect.promise(() => discoverTool(registry, name, binding))
+        (registry) => Effect.promise(() => discoverTool(registry, segment, ctx))
       ),
-      Effect.flatMap((outcome) => settle(name, outcome))
+      Effect.flatMap((outcome) => settleDiscovery(segment, outcome))
     )
   };
 };
 export {
   CallError,
+  DiscoverError,
   localRunner
 };

package/dist/runner/protocol.d.ts

@@ -1,13 +1,26 @@
 import { type Effect, FileSystem } from "effect";
 import type { AppManifestResult, PublishError } from "../manifest/contract";
-import type { ToolCtx } from "../runtime/index";
-export type { ToolCtx, ToolCtxEntry } from "../runtime/index";
+import type { CallFailureKind, DiscoveredTool, ToolCtx } from "../runtime/index";
+export type { DiscoveredTool, ToolCtx, ToolCtxEntry, ToolDescriptor, } from "../runtime/index";
+/** Which invocation phase failed. */
+export type CallErrorKind = CallFailureKind;
 declare const CallError_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: "CallError";
 } & Readonly<A>;
-/** A runner operation failure associated with its target. */
+/** A runner operation failure associated with its target and phase. */
 export declare class CallError extends CallError_base<{
     readonly target: string;
+    readonly kind: CallErrorKind;
+    readonly reason: string;
+}> {
+    get message(): string;
+}
+declare const DiscoverError_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: "DiscoverError";
+} & Readonly<A>;
+/** A discovery failure associated with one dynamic segment. */
+export declare class DiscoverError extends DiscoverError_base<{
+    readonly segment: string;
     readonly reason: string;
 }> {
     get message(): string;
@@ -15,6 +28,6 @@ export declare class CallError extends CallError_base<{
 /** The platform protocol implemented by an app execution environment. */
 export interface AppRunner {
     manifest(): Effect.Effect<AppManifestResult, PublishError, FileSystem.FileSystem>;
-    call(name: string, input: unknown, ctx: ToolCtx): Effect.Effect<unknown, CallError, FileSystem.FileSystem>;
-    discover(name: string, binding: unknown): Effect.Effect<unknown, CallError, FileSystem.FileSystem>;
+    call(address: string, input: unknown, ctx: ToolCtx, detail?: unknown): Effect.Effect<unknown, CallError, FileSystem.FileSystem>;
+    discover(segment: string, ctx: ToolCtx): Effect.Effect<readonly DiscoveredTool[], DiscoverError, FileSystem.FileSystem>;
 }

package/dist/runner/protocol.js

@@ -1,6 +1,8 @@
 import {
-  CallError
-} from "../chunk-NFLNA2SC.js";
+  CallError,
+  DiscoverError
+} from "../chunk-4OZFMCTT.js";
 export {
-  CallError
+  CallError,
+  DiscoverError
 };

package/dist/runtime/index.d.ts

@@ -12,11 +12,14 @@
  * and workerd all provide.
  */
 import type { Registry } from "../authoring/index";
-import type { AppManifestResult } from "../manifest/contract";
+import type { AppManifestResult, JsonSchemaObject } from "../manifest/contract";
 /** The capability exposed to one tool requirement role. */
 export interface ToolCtxEntry {
     readonly grant: string;
+    readonly kind: "bearer" | "basic" | "secrets" | "oauth";
     readonly token?: string;
+    readonly username?: string;
+    readonly password?: string;
     readonly secrets?: Readonly<Record<string, string>>;
     fetch(path: string, init?: RequestInit): Promise<Response>;
 }
@@ -30,17 +33,51 @@ export type ManifestOutcome = {
     readonly ok: false;
     readonly problems: readonly string[];
 };
+/** Which invocation phase failed. */
+export type CallFailureKind = "input" | "handler";
 /** One tool invocation's result envelope. */
 export type CallOutcome = {
     readonly ok: true;
     readonly value: unknown;
 } | {
     readonly ok: false;
+    readonly kind: CallFailureKind;
     readonly reason: string;
 };
+/** Agent-facing descriptor compiled from one discovery result. */
+export interface ToolDescriptor {
+    readonly description: string;
+    readonly inputSchema: JsonSchemaObject;
+    readonly annotations: {
+        readonly readOnly?: boolean;
+        readonly destructive?: boolean;
+    };
+}
+/** One tool emitted by a dynamic segment discovery. */
+export interface DiscoveredTool {
+    readonly segment: string;
+    readonly name: string;
+    readonly descriptor: ToolDescriptor;
+    readonly detail: unknown;
+}
+/** One dynamic discovery result envelope. */
+export type DiscoverOutcome = {
+    readonly ok: true;
+    readonly value: readonly DiscoveredTool[];
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+type InputSchemaCompilation = {
+    readonly value: JsonSchemaObject;
+} | {
+    readonly problem: string;
+};
+export declare const compileInputSchema: (input: object, where: string) => InputSchemaCompilation;
 /** Project a loaded registry into the app's deterministic manifest. */
 export declare const manifestOf: (registry: Registry) => Promise<ManifestOutcome>;
-/** Validate input and run one registered tool's handler. */
-export declare const callTool: (registry: Registry, name: string, input: unknown, ctx: ToolCtx) => Promise<CallOutcome>;
-/** Discover one dynamic tool set's current segment. Unbuilt: always fails. */
-export declare const discoverTool: (_registry: Registry, _name: string, _binding: unknown) => Promise<CallOutcome>;
+/** Validate input and run one static or dynamic tool handler. */
+export declare const callTool: (registry: Registry, address: string, input: unknown, ctx: ToolCtx, detail?: unknown) => Promise<CallOutcome>;
+/** Discover and compile one dynamic segment. */
+export declare const discoverTool: (registry: Registry, segment: string, ctx: ToolCtx) => Promise<DiscoverOutcome>;
+export {};

package/dist/runtime/index.js

@@ -1,10 +1,12 @@
 import {
   callTool,
+  compileInputSchema,
   discoverTool,
   manifestOf
-} from "../chunk-OGCPVWAZ.js";
+} from "../chunk-MUFMJRXR.js";
 export {
   callTool,
+  compileInputSchema,
   discoverTool,
   manifestOf
 };

package/dist/workerd/index.d.ts

@@ -4,4 +4,4 @@
  * exposes these verbs over RPC; the logic itself lives in ../runtime
  * and is identical to what the local runner executes. @internal
  */
-export { callTool, discoverTool, manifestOf, type CallOutcome, type ManifestOutcome, type ToolCtx, type ToolCtxEntry, } from "../runtime/index";
+export { callTool, discoverTool, manifestOf, type CallOutcome, type DiscoverOutcome, type DiscoveredTool, type ManifestOutcome, type ToolCtx, type ToolCtxEntry, } from "../runtime/index";