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

package/dist/{chunk-LWKQDDLZ.js → chunk-535V5K64.js}

@@ -1,8 +1,45 @@
 // src/authoring/index.ts
+var bearer = (opts) => ({ kind: "bearer", ...opts });
+var basic = (opts) => ({ kind: "basic", ...opts });
 var secrets = (opts) => ({ kind: "secrets", ...opts });
 var oauth = (opts) => ({ kind: "oauth", ...opts });
 var RequirementKey = Symbol.for("executor/apps/requirement");
+var ServiceDeclKey = Symbol.for("executor/apps/service-decl");
+var recordAuthoringProblem = (message) => {
+  const file = sourceFileFor("wrapper");
+  activeRegistry.problems.push({ message: `${file}: ${message}` });
+};
 var DynamicKey = Symbol.for("executor/apps/dynamic");
+var dynamicSpecOf = (value) => typeof value === "object" && value !== null && DynamicKey in value ? value[DynamicKey] : void 0;
+var defineDynamicTools = (decl) => {
+  const spec = decl;
+  const file = sourceFileFor("defineDynamicTools(...)");
+  const problems = [];
+  if (typeof spec.description !== "string" || spec.description.trim().length === 0)
+    problems.push("dynamic tool set description must not be empty");
+  const roles = Object.entries(spec.requirements ?? {});
+  if (roles.length > 1) problems.push("a dynamic tool set takes exactly one requirement role");
+  else if (roles.length === 1) {
+    const [role, value] = roles[0];
+    const requirementSpec = requirementSpecOf(value);
+    if (requirementSpec === void 0)
+      problems.push(`requirement '${role}' is not a service/requirement value`);
+    else if (requirementSpec.arity === "many")
+      problems.push(
+        `requirement '${role}' cannot be .array() \u2014 multiple accounts expand the catalog per connection, never merge one list`
+      );
+  }
+  if (problems.length > 0) {
+    activeRegistry.problems.push(...problems.map((message) => ({ message: `${file}: ${message}` })));
+    return { [DynamicKey]: void 0 };
+  }
+  if (activeRegistry.dynamic.has(file))
+    activeRegistry.problems.push({
+      message: `${file}: one dynamic tool set per file \u2014 its address segment is the file's name`
+    });
+  else activeRegistry.dynamic.set(file, { spec, file });
+  return { [DynamicKey]: spec };
+};
 var newRegistry = () => ({
   app: void 0,
   services: /* @__PURE__ */ new Map(),
@@ -37,12 +74,23 @@ var makeTerminal = (spec) => ({
 });
 var service = (decl) => {
   const file = sourceFileFor("service(...)");
+  const makePinned = (spec) => ({
+    [RequirementKey]: spec,
+    optional: () => makeTerminal({ ...spec, arity: "optional" }),
+    array: () => makeTerminal({ ...spec, arity: "many" }),
+    describe: (text) => makePinned({ ...spec, description: text })
+  });
   const make = (spec) => ({
     [RequirementKey]: spec,
-    decl,
+    [ServiceDeclKey]: decl,
+    auth: Object.fromEntries(
+      Object.keys(decl.auth ?? {}).map((name) => [
+        name,
+        makePinned({ ...spec, grant: name })
+      ])
+    ),
     optional: () => makeTerminal({ ...spec, arity: "optional" }),
     array: () => makeTerminal({ ...spec, arity: "many" }),
-    grant: (name) => make({ ...spec, grant: name }),
     describe: (text) => make({ ...spec, description: text })
   });
   const value = make({ service: decl, arity: "one" });
@@ -51,7 +99,7 @@ var service = (decl) => {
   return value;
 };
 var isRequirement = (value) => typeof value === "object" && value !== null && RequirementKey in value;
-var isService = (value) => isRequirement(value) && "decl" in value && "optional" in value && "array" in value && "grant" in value;
+var isService = (value) => isRequirement(value) && ServiceDeclKey in value;
 var requirementSpecOf = (value) => isService(value) || isRequirement(value) ? value[RequirementKey] : void 0;
 var defineApp = (manifest) => {
   const file = sourceFileFor("defineApp(...)");
@@ -61,7 +109,11 @@ var defineApp = (manifest) => {
   return value;
 };
 var ToolKey = Symbol.for("executor/apps/tool");
-var defineTool = (spec) => {
+var defineTool = (decl) => {
+  const spec = decl;
+  return registerTool(spec);
+};
+var registerTool = (spec) => {
   const file = sourceFileFor("defineTool(...)");
   const value = { [ToolKey]: spec };
   const fileName = file.slice(file.lastIndexOf("/") + 1);
@@ -84,8 +136,13 @@ var isTool = (value) => typeof value === "object" && value !== null && ToolKey i
 var toolSpecOf = (value) => isTool(value) ? value[ToolKey] : void 0;
 
 export {
+  bearer,
+  basic,
   secrets,
   oauth,
+  recordAuthoringProblem,
+  dynamicSpecOf,
+  defineDynamicTools,
   newRegistry,
   setActiveRegistry,
   __enterFile,

package/dist/chunk-DP6UJCMX.js

@@ -0,0 +1,27 @@
+import {
+  defineDynamicTools
+} from "./chunk-535V5K64.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/chunk-QA72XJZU.js

@@ -0,0 +1,41 @@
+import {
+  defineDynamicTools,
+  recordAuthoringProblem,
+  requirementSpecOf
+} from "./chunk-535V5K64.js";
+
+// src/openapi/mapper.ts
+var openapiDiscover = async (_spec, _ctx, _auth, _operations) => {
+  throw new Error("openapi mapper not built yet");
+};
+var openapiCall = async (_tool, _input, _ctx, _auth) => {
+  throw new Error("openapi mapper not built yet");
+};
+
+// src/openapi/index.ts
+var enforceSecretsPlacement = (requirements, auth) => {
+  if (auth !== void 0) return;
+  for (const value of Object.values(requirements ?? {})) {
+    const spec = requirementSpecOf(value);
+    const methods = spec?.grant === void 0 ? Object.values(spec?.service.auth ?? {}) : [spec.service.auth?.[spec.grant]].filter((method) => method !== void 0);
+    if (methods.some((method) => method.kind === "secrets"))
+      recordAuthoringProblem(
+        "fromOpenAPI: the service offers a secrets() auth method, so 'auth' must state how the credential rides"
+      );
+  }
+};
+function fromOpenAPI(spec, options) {
+  enforceSecretsPlacement(options?.requirements, options?.auth);
+  const auth = options?.auth;
+  const operations = options?.operations;
+  return defineDynamicTools({
+    description: typeof spec === "string" && spec.startsWith("https://") ? `Operations from the OpenAPI document at ${spec}.` : "Operations from an OpenAPI document shipped with the app.",
+    ...options?.requirements === void 0 ? {} : { requirements: options.requirements },
+    discover: ({ ctx }) => openapiDiscover(spec, ctx, auth, operations),
+    call: ({ tool, input, ctx }) => openapiCall(tool, input, ctx, auth)
+  });
+}
+
+export {
+  fromOpenAPI
+};

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-XYT6GZ7M.js}

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

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-QA72XJZU.js";
+import {
+  authHeaders
+} from "./chunk-S5KFP4JQ.js";
+import {
+  fromMCP
+} from "./chunk-DP6UJCMX.js";
 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,
+  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-XYT6GZ7M.js";
+import "../chunk-2DVKSPQH.js";
 import {
   JsonSchemaObject,
   PublishError
 } from "../chunk-B7NEUIJL.js";
-import "../chunk-OGCPVWAZ.js";
+import "../chunk-535V5K64.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-DP6UJCMX.js";
+import "../chunk-535V5K64.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-QA72XJZU.js";
+import "../chunk-535V5K64.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-XYT6GZ7M.js";
 import {
   callTool,
   discoverTool
-} from "../chunk-OGCPVWAZ.js";
+} from "../chunk-2DVKSPQH.js";
+import "../chunk-B7NEUIJL.js";
+import {
+  CallError,
+  DiscoverError
+} from "../chunk-4OZFMCTT.js";
+import "../chunk-535V5K64.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-2DVKSPQH.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";

package/dist/workerd/index.js

@@ -2,7 +2,7 @@ import {
   callTool,
   discoverTool,
   manifestOf
-} from "../chunk-OGCPVWAZ.js";
+} from "../chunk-2DVKSPQH.js";
 export {
   callTool,
   discoverTool,