apps 0.0.1-beta.5 → 0.0.1-beta.6

package/types/apps/src/implementation/router.d.ts

@@ -0,0 +1,59 @@
+import { HostedTool } from "../contracts/host.js";
+import type { AppOperation } from "../contracts/operations.js";
+import { RouterMeta, type AppRouter, type DynamicRouter, type RouterIcon } from "../contracts/router.js";
+import { type OperationDeclaration, type RouterChild, type RouterDeclaration } from "./operations.js";
+export type { RouterChild, RouterDeclaration } from "./operations.js";
+/** Author metadata for a router. Instructions become a skill named after the router's path. */
+export interface RouterOptions {
+    readonly title?: string;
+    readonly description?: string;
+    readonly instructions?: string;
+    readonly icons?: readonly RouterIcon[];
+    readonly tags?: Readonly<Record<string, string>>;
+}
+/** Wrap a native router. Protocol helpers use this for the routers they build. */
+export declare const routerDeclaration: (node: AppRouter | DynamicRouter) => RouterDeclaration;
+/** Accept only framework-created routers. */
+export declare const nativeRouter: (value: unknown) => AppRouter | DynamicRouter | undefined;
+/** Author fields win; a field the author omits keeps the source's value. */
+export declare const mergeMeta: (base: RouterMeta | undefined, override: RouterMeta | undefined) => RouterMeta | undefined;
+/**
+ * Group operations and routers under path keys, like tRPC's nested routers, with metadata an
+ * agent can read. Passing an existing router instead of children overrides its metadata:
+ * `router(mcpRouter(options), { description: "..." })`.
+ */
+export declare function router<Query = unknown, Mutation = unknown>(children: Readonly<Record<string, RouterChild<Query, Mutation>>>, options?: RouterOptions): RouterDeclaration<Query, Mutation>;
+export declare function router<Query, Mutation>(source: RouterDeclaration<Query, Mutation>, options: RouterOptions): RouterDeclaration<Query, Mutation>;
+/**
+ * Declare a router whose tools are discovered when read. `list` returns tools with names relative
+ * to this router; mark queries with `readOnly: true`. `resolve` receives one of those names.
+ */
+export declare const dynamicRouter: (source: {
+    readonly meta?: () => RouterOptions | Promise<RouterOptions>;
+    readonly list: () => readonly HostedTool[] | Promise<readonly HostedTool[]>;
+    readonly resolve: (name: string) => OperationDeclaration<"query" | "mutation", unknown> | undefined | Promise<OperationDeclaration<"query" | "mutation", unknown> | undefined>;
+}) => RouterDeclaration;
+/** Join a router path and a relative name. The root router's path is "". */
+export declare const joinPath: (path: string, name: string) => string;
+/** Where a full tool name points: a declared operation, or a name inside a dynamic router. */
+export type Location = {
+    readonly kind: "operation";
+    readonly operation: AppOperation;
+    readonly router: string;
+} | {
+    readonly kind: "dynamic";
+    readonly source: DynamicRouter;
+    readonly router: string;
+    readonly name: string;
+};
+/**
+ * Walk static keys until the name ends at an operation or enters a dynamic router, which receives
+ * the rest of the name. Static keys contain no dots, so every name has at most one location.
+ */
+export declare const locate: (root: AppRouter | DynamicRouter | undefined, name: string) => Location | undefined;
+/** Every declared operation with its full name and owning router. Dynamic routers are not listed. */
+export declare const declaredOperations: (root: AppRouter | undefined, path?: string) => Array<{
+    readonly name: string;
+    readonly router: string;
+    readonly operation: AppOperation;
+}>;

package/types/apps/src/implementation/schema.d.ts

@@ -1,6 +1,6 @@
 /** Author schema facade. Internals use the native decoder retained by each value. */
 import { Effect, Schema as EffectSchema } from "effect";
-import { ValidationError, type JsonObject } from "../contracts/schema.js";
+import { JsonObject, ValidationError } from "../contracts/schema.js";
 import type { Field } from "../../../app-data/src/contracts/database.js";
 declare const StorageField: unique symbol;
 declare const Decoder: unique symbol;
@@ -91,4 +91,8 @@ export declare const storageFieldOf: (schema: Schema<unknown, boolean>) => Field
 export declare const id: (table: string) => Schema<string>;
 /** A host user identifier, stored as a string without imposing a product auth model. */
 export declare const userId: () => Schema<string>;
+/** Render a decoder as a JSON Schema document, keeping an imported upstream document as-is. */
+export declare const jsonSchemaDocument: (decoder: EffectSchema.Decoder<unknown>) => Effect.Effect<{
+    readonly [x: string]: EffectSchema.Json;
+}, EffectSchema.SchemaError, never>;
 export {};

package/types/apps/src/implementation/workflow-context.d.ts

@@ -8,7 +8,7 @@ import { WorkflowFailure, type WorkflowContext, type WorkflowExecution, type Wor
  */
 export declare const workflowSafe: <A>(work: Effect.Effect<A, unknown>, secrets: readonly string[]) => Effect.Effect<A, WorkflowFailure>;
 /** Construct one replay's Promise context. Step callbacks acquire fresh capabilities per actual attempt. */
-export declare const makeWorkflowContext: (execution: WorkflowExecution, definition: Pick<AppDefinition<never>, "queries" | "mutations">, 
+export declare const makeWorkflowContext: (execution: WorkflowExecution, definition: Pick<AppDefinition<never>, "tools">, 
 /** A step attempt's context, and the raw account secrets its failures must not reveal. */
 fresh: (stepId: string, signal: AbortSignal) => Effect.Effect<{
     readonly context: WorkflowStepContext;

package/types/apps/src/index.d.ts

@@ -16,8 +16,9 @@ export { type JsonObject, type JsonValue, ValidationError } from "./contracts/sc
 export { type Fields, type Infer, type ObjectSchema, type ObjectValue, type Schema, array, boolean, json, jsonSchema, literal, number, object, record, string, } from "./implementation/schema.js";
 export { type AccountOf, type AuthMethod, type AuthMethodData, type AuthMethods, type ManyAccounts, type OAuth2Config, type Provider, } from "./contracts/provider.js";
 export { defineProvider } from "./implementation/provider.js";
-export { accountOperations } from "./implementation/account-operations.js";
-export { dynamicTools } from "./implementation/dynamic-tools.js";
+export { accountRouter } from "./implementation/account-router.js";
+export { router, dynamicRouter, type RouterDeclaration, type RouterChild, type RouterOptions, } from "./implementation/router.js";
+export type { RouterIcon } from "./contracts/router.js";
 export { dynamicSkills } from "./implementation/dynamic-skills.js";
 export type { HostedTool as OperationDescription } from "./contracts/host.js";
 /** A secrets declaration inferred from an author schema. */

package/types/apps/src/mcp-stdio.d.ts

@@ -1,8 +1,5 @@
 import type { ProcessConfig } from "./contracts/mcp.js";
 import { type OperationKinds } from "./implementation/protocol-operations.js";
 export { McpError, type McpToolContext, type ProcessConfig } from "./contracts/mcp.js";
-/** Discover an account's tools; each discovery and call owns and closes its subprocess. */
-export declare const stdioOperations: (config: ProcessConfig, signal?: AbortSignal, kinds?: OperationKinds) => Promise<{
-    queries: Record<string, import("./index.js").Operation<import("effect/Schema").Json, unknown, "query", import("./index.js").OperationContext>>;
-    mutations: Record<string, import("./index.js").Operation<import("effect/Schema").Json, unknown, "mutation", import("./index.js").OperationContext>>;
-}>;
+/** Discover an account's tools as a router; each discovery and call owns and closes its subprocess. */
+export declare const stdioRouter: (config: ProcessConfig, signal?: AbortSignal, kinds?: OperationKinds) => Promise<import("./index.js").RouterDeclaration<unknown, unknown>>;

package/types/apps/src/mcp.d.ts

@@ -3,8 +3,9 @@ import type { OperationKinds } from "./implementation/protocol-operations.js";
 import { type McpCatalogOptions } from "./implementation/mcp-catalog.js";
 export type { McpCatalogOptions } from "./implementation/mcp-catalog.js";
 export { McpError, type McpToolContext, type McpToolsOptions, type McpToolResult, } from "./contracts/mcp.js";
-/** Discover operations for the selected account. Kinds override uncertain upstream read-only hints. */
-export declare const mcpOperations: (options: McpCatalogOptions, kinds?: OperationKinds) => Promise<{
-    dynamicTools: import("./contracts/dynamic-tools.js").DynamicTools;
-}>;
+/**
+ * A router over a server's tools for the selected account. Its title, description and
+ * instructions come from the server. Kinds override uncertain upstream read-only hints.
+ */
+export declare const mcpRouter: (options: McpCatalogOptions, kinds?: OperationKinds) => Promise<import("./index.js").RouterDeclaration<unknown, unknown>>;
 export type { OperationKinds } from "./implementation/protocol-operations.js";

package/types/apps/src/openapi.d.ts

@@ -2,11 +2,11 @@
 import { type OperationKinds } from "./implementation/protocol-operations.js";
 import type { OpenapiToolsOptions } from "./contracts/openapi.js";
 export { OpenapiError, isOpenapiTextMedia, openapiBinaryResultSchema, OpenapiErrorResponse, type OpenapiToolsOptions, type OpenapiOperation, type CredentialBinding, OpenapiParameter, OpenapiRequestBody, openapiMediaKind, } from "./contracts/openapi.js";
-/** Discover operations for the selected account. Kinds override uncertain upstream read-only hints. */
-export declare const openapiOperations: (options: OpenapiToolsOptions, kinds?: OperationKinds) => Promise<{
-    queries: Record<string, import("./index.js").Operation<import("effect/Schema").Json, unknown, "query", import("./index.js").OperationContext>>;
-    mutations: Record<string, import("./index.js").Operation<import("effect/Schema").Json, unknown, "mutation", import("./index.js").OperationContext>>;
-}>;
+/**
+ * Discover a document's operations as a router for the selected account. Kinds override uncertain
+ * upstream read-only hints. Mount it under a key, or override its metadata with `router(...)`.
+ */
+export declare const openapiRouter: (options: OpenapiToolsOptions, kinds?: OperationKinds) => Promise<import("./index.js").RouterDeclaration<unknown, unknown>>;
 export type { OperationKinds } from "./implementation/protocol-operations.js";
 export * from "./contracts/openapi-compile.js";
-export { liveOpenapiOperations, type OpenapiSourceOptions, } from "./implementation/openapi-source.js";
+export { liveOpenapiRouter, type OpenapiSourceOptions } from "./implementation/openapi-source.js";

package/js/chunk-3XKZDQLM.js

@@ -1,93 +0,0 @@
-import {
-  decoderOf
-} from "./chunk-FWQC6I3C.js";
-import {
-  Effect_exports
-} from "./chunk-CDL5PM2Q.js";
-
-// src/implementation/authoring.ts
-var NativeCallback = /* @__PURE__ */ Symbol("apps.NativeCallback");
-var fromPromise = (callback) => (...args) => {
-  if (NativeCallback in callback) {
-    const native = callback[NativeCallback];
-    return native(...args);
-  }
-  return Effect_exports.tryPromise({ try: () => callback(...args), catch: (error) => error });
-};
-var toPromise = (operation, signal) => {
-  const native = (...args) => Effect_exports.suspend(() => {
-    if (signal === void 0) return operation(...args);
-    if (signal.aborted) return Effect_exports.interrupt;
-    const cancelled = Effect_exports.callback((resume) => {
-      if (signal.aborted) {
-        resume(Effect_exports.interrupt);
-        return;
-      }
-      const abort = () => resume(Effect_exports.interrupt);
-      signal.addEventListener("abort", abort, { once: true });
-      return Effect_exports.sync(() => signal.removeEventListener("abort", abort));
-    });
-    return Effect_exports.raceFirst(
-      cancelled,
-      Effect_exports.suspend(() => operation(...args))
-    );
-  });
-  return Object.assign((...args) => Effect_exports.runPromise(native(...args)), {
-    [NativeCallback]: native
-  });
-};
-
-// src/implementation/operations.ts
-var NativeOperation = /* @__PURE__ */ Symbol("apps.Operation");
-var operationDeclaration = (operation) => ({
-  kind: operation.kind,
-  [NativeOperation]: operation
-});
-var nativeOperation = (value) => {
-  if (typeof value !== "object" || value === null || !(NativeOperation in value)) return void 0;
-  return value[NativeOperation];
-};
-var operationOptions = (options) => {
-  const approval = options.approval;
-  return {
-    ...options.description === void 0 ? {} : { description: options.description },
-    ...options.title === void 0 ? {} : { title: options.title },
-    ...options.annotations === void 0 ? {} : { annotations: options.annotations },
-    ...options._meta === void 0 ? {} : { _meta: options._meta },
-    input: decoderOf(options.input),
-    ...approval === void 0 ? {} : {
-      approval: (context) => Effect_exports.tryPromise({ try: async () => approval(context), catch: (error) => error })
-    }
-  };
-};
-var withApproval = (operation, approval) => ({
-  ...operation,
-  [NativeOperation]: {
-    ...operation[NativeOperation],
-    approval: (context) => Effect_exports.tryPromise({ try: async () => approval(context), catch: (error) => error })
-  }
-});
-var make = (kind, options, run) => operationDeclaration({
-  ...operationOptions(options),
-  kind,
-  // The host always validates JSON serialization, even without a stronger output declaration.
-  ...options.output === void 0 ? {} : { output: decoderOf(options.output) },
-  run: (context, input) => Effect_exports.tryPromise({
-    // SAFETY: defineApp checks the handler context against its requirements.
-    // The host validates account bindings and creates the matching storage facade.
-    try: () => run(context, input),
-    catch: (error) => error
-  })
-});
-var query = (options, run) => make("query", options, run);
-var mutation = (options, run) => make("mutation", options, run);
-
-export {
-  fromPromise,
-  toPromise,
-  operationDeclaration,
-  nativeOperation,
-  withApproval,
-  query,
-  mutation
-};

package/js/chunk-4M277YTM.js

@@ -1,136 +0,0 @@
-import {
-  ApiErrorResponse
-} from "./chunk-W4DMKWAB.js";
-import {
-  AccountId,
-  HttpUrl,
-  JsonObject
-} from "./chunk-27F7W2LG.js";
-import {
-  Schema_exports
-} from "./chunk-CDL5PM2Q.js";
-
-// src/contracts/openapi.ts
-var OpenapiErrorResponse = Schema_exports.Struct({
-  code: ApiErrorResponse.fields.code,
-  status: ApiErrorResponse.fields.status,
-  message: Schema_exports.Union([
-    Schema_exports.Struct({ source: Schema_exports.Literal("body") }),
-    Schema_exports.Struct({ source: Schema_exports.Literal("schema"), value: ApiErrorResponse.fields.message })
-  ]),
-  schema: JsonObject
-});
-var OpenapiParameter = Schema_exports.Struct({
-  name: Schema_exports.String,
-  in: Schema_exports.Literals(["path", "query", "header", "cookie"]),
-  required: Schema_exports.optionalKey(Schema_exports.Boolean),
-  schema: Schema_exports.optionalKey(JsonObject),
-  style: Schema_exports.optionalKey(Schema_exports.String),
-  explode: Schema_exports.optionalKey(Schema_exports.Boolean),
-  allowReserved: Schema_exports.optionalKey(Schema_exports.Boolean),
-  allowEmptyValue: Schema_exports.optionalKey(Schema_exports.Boolean),
-  content: Schema_exports.optionalKey(JsonObject)
-});
-var OpenapiRequestBody = Schema_exports.Struct({
-  required: Schema_exports.optionalKey(Schema_exports.Boolean),
-  content: Schema_exports.Record(
-    Schema_exports.String,
-    Schema_exports.Struct({
-      schema: Schema_exports.optionalKey(JsonObject),
-      encoding: Schema_exports.optionalKey(JsonObject)
-    })
-  )
-});
-var OpenapiOperation = Schema_exports.Struct({
-  /** The tool name after `queries.` or `mutations.`, grouped as `<group>.<leaf>`. */
-  name: Schema_exports.NonEmptyString,
-  /** The document's operationId, when it declares one. `kinds` overrides are keyed by it. */
-  operationId: Schema_exports.optionalKey(Schema_exports.String),
-  description: Schema_exports.String,
-  method: Schema_exports.Literals(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]),
-  path: Schema_exports.String,
-  baseUrl: HttpUrl,
-  openapi: Schema_exports.String,
-  securitySchemes: Schema_exports.Record(Schema_exports.String, JsonObject),
-  /** The resolved OpenAPI Operation Object; Executor schemas remain separate. */
-  request: Schema_exports.Struct({
-    parameters: Schema_exports.Array(OpenapiParameter),
-    requestBody: Schema_exports.optionalKey(OpenapiRequestBody),
-    security: Schema_exports.Array(Schema_exports.Record(Schema_exports.String, Schema_exports.Array(Schema_exports.String))),
-    responses: Schema_exports.Record(Schema_exports.String, JsonObject)
-  }),
-  /** Streams remain in the metadata but cannot run through a single-result tool call. */
-  streaming: Schema_exports.optionalKey(Schema_exports.Literal(true)),
-  input: JsonObject,
-  outputSchema: Schema_exports.optionalKey(JsonObject),
-  errorResponses: Schema_exports.optionalKey(Schema_exports.Array(OpenapiErrorResponse))
-});
-var CredentialBinding = Schema_exports.Struct({
-  scheme: Schema_exports.String,
-  field: Schema_exports.String,
-  part: Schema_exports.Literals(["value", "username", "password"]),
-  prefix: Schema_exports.String
-});
-var OpenapiAccount = Schema_exports.Struct({
-  id: Schema_exports.optional(AccountId),
-  method: Schema_exports.String,
-  fields: Schema_exports.Record(Schema_exports.String, Schema_exports.Unknown)
-});
-var OpenapiParameterDefaults = Schema_exports.Struct({
-  path: Schema_exports.optionalKey(Schema_exports.Record(Schema_exports.String, Schema_exports.String)),
-  query: Schema_exports.optionalKey(Schema_exports.Record(Schema_exports.String, Schema_exports.String)),
-  headers: Schema_exports.optionalKey(Schema_exports.Record(Schema_exports.String, Schema_exports.String))
-});
-var OpenapiToolsOptions = Schema_exports.Struct({
-  operations: Schema_exports.Array(OpenapiOperation),
-  /**
-   * Component schemas stored once per app and referenced as `#/$defs/<name>`. Operations
-   * generated before shared definitions carry their own `$defs` and omit this.
-   */
-  definitions: Schema_exports.optional(Schema_exports.Record(Schema_exports.String, JsonObject)),
-  methods: Schema_exports.Record(Schema_exports.String, Schema_exports.Array(CredentialBinding)),
-  oauth: Schema_exports.Array(Schema_exports.String),
-  account: Schema_exports.optional(OpenapiAccount),
-  parameterDefaults: Schema_exports.optional(OpenapiParameterDefaults),
-  signal: Schema_exports.optional(Schema_exports.instanceOf(AbortSignal)),
-  fetch: Schema_exports.optional(
-    Schema_exports.declare((value) => typeof value === "function")
-  )
-});
-var OpenapiError = class extends Schema_exports.TaggedError()("OpenapiError", {
-  reason: Schema_exports.Literals(["invalid_definition", "invalid_input", "request"]),
-  status: Schema_exports.optional(Schema_exports.Number)
-}) {
-};
-var defaultOpenapiResponseLimits = {
-  maxBodyBytes: 16777216,
-  readTimeoutMs: 3e4
-};
-var isOpenapiTextMedia = (type) => /^(?:text\/|application\/(?:[\w.-]+\+)?(?:json|xml)|application\/(?:javascript|x-ndjson|x-www-form-urlencoded))/i.test(
-  type
-);
-var isOpenapiFileSchema = (shape) => shape.contentMediaType !== void 0 && shape.contentEncoding === void 0 || shape.type === "string" && shape.format === "binary";
-var openapiBinaryResultSchema = {
-  type: "object",
-  properties: {
-    base64: { type: "string", contentEncoding: "base64" },
-    contentType: { type: "string" }
-  },
-  required: ["base64", "contentType"],
-  additionalProperties: false
-};
-var openapiMediaKind = (type) => type.includes("json") && !type.includes("ndjson") ? "json" : type === "application/x-www-form-urlencoded" ? "form" : type === "multipart/form-data" ? "multipart" : isOpenapiTextMedia(type) ? "text" : "binary";
-
-export {
-  OpenapiErrorResponse,
-  OpenapiParameter,
-  OpenapiRequestBody,
-  OpenapiOperation,
-  OpenapiToolsOptions,
-  OpenapiError,
-  defaultOpenapiResponseLimits,
-  isOpenapiTextMedia,
-  isOpenapiFileSchema,
-  openapiBinaryResultSchema,
-  openapiMediaKind
-};

package/js/chunk-SB3V4YVR.js

@@ -1,18 +0,0 @@
-import {
-  AccountId
-} from "./chunk-27F7W2LG.js";
-import {
-  Schema_exports
-} from "./chunk-CDL5PM2Q.js";
-
-// src/contracts/provider-error.ts
-var ProviderError = class extends Schema_exports.TaggedError()("ProviderError", {
-  reason: Schema_exports.Literals(["unauthorized", "forbidden", "rate_limited", "unavailable", "rejected"]),
-  status: Schema_exports.optional(Schema_exports.Int.check(Schema_exports.isBetween({ minimum: 100, maximum: 599 }))),
-  accountId: Schema_exports.optional(AccountId)
-}) {
-};
-
-export {
-  ProviderError
-};

package/js/chunk-W4DMKWAB.js

@@ -1,35 +0,0 @@
-import {
-  Schema_exports
-} from "./chunk-CDL5PM2Q.js";
-
-// src/contracts/api-response-error.ts
-var ApiErrorRecovery = Schema_exports.Struct({
-  action: Schema_exports.NonEmptyString.check(Schema_exports.isMaxLength(1024)),
-  instructions: Schema_exports.NonEmptyString.check(Schema_exports.isMaxLength(4096))
-});
-var ApiErrorResponse = Schema_exports.Struct({
-  code: Schema_exports.NonEmptyString.check(Schema_exports.isMaxLength(128)),
-  status: Schema_exports.Int.check(Schema_exports.isBetween({ minimum: 400, maximum: 599 })),
-  message: Schema_exports.NonEmptyString.check(Schema_exports.isMaxLength(4096)),
-  recovery: Schema_exports.optionalKey(ApiErrorRecovery)
-});
-var OpenapiResponseError = class extends Schema_exports.TaggedError()(
-  "OpenapiResponseError",
-  ApiErrorResponse.fields
-) {
-};
-var OpenapiErrorLimits = Schema_exports.Struct({
-  maxBodyBytes: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
-  readTimeoutMs: Schema_exports.Int.check(Schema_exports.isGreaterThan(0))
-});
-var defaultOpenapiErrorLimits = OpenapiErrorLimits.make({
-  maxBodyBytes: 65536,
-  readTimeoutMs: 2e3
-});
-
-export {
-  ApiErrorRecovery,
-  ApiErrorResponse,
-  OpenapiResponseError,
-  defaultOpenapiErrorLimits
-};

package/types/apps/src/contracts/dynamic-tools.d.ts

@@ -1,13 +0,0 @@
-/** Lazy operation discovery and resolution. Executables remain invocation-owned. */
-import type { Effect } from "effect";
-import type { HostedTool, HostedToolSummary } from "./host.js";
-import type { AppOperation } from "./operations.js";
-/** Tool names include their queries./mutations. prefix. Resolution never requires listing. */
-export interface DynamicTools {
-    readonly list: () => Effect.Effect<readonly HostedTool[], unknown>;
-    readonly resolve: (name: string) => Effect.Effect<AppOperation | undefined, unknown>;
-    /** Names and descriptions without schemas. Omitted sources reduce list(). */
-    readonly summaries?: () => Effect.Effect<readonly HostedToolSummary[], unknown>;
-    /** One tool's full metadata without listing. Omitted sources search list(). */
-    readonly describe?: (name: string) => Effect.Effect<HostedTool | undefined, unknown>;
-}

package/types/apps/src/implementation/account-operations.d.ts

@@ -1,151 +0,0 @@
-/** Combine account-bound protocol operations without changing their upstream inputs. */
-import { Effect, Schema } from "effect";
-import type { DynamicTools } from "../contracts/dynamic-tools.js";
-import type { AppOperation, OperationContext } from "../contracts/operations.js";
-import { type JsonValue } from "../contracts/schema.js";
-import { type Operation } from "./operations.js";
-type Operations = {
-    readonly queries?: Readonly<Record<string, Operation<JsonValue, unknown, "query", OperationContext>>>;
-    readonly dynamicTools?: DynamicTools;
-    readonly mutations?: Readonly<Record<string, Operation<JsonValue, unknown, "mutation", OperationContext>>>;
-};
-/**
- * Discover each selected account's protocol operations and combine matching names.
- * Calls take { accountId, input }; each branch retains its account's input schema,
- * credentials, approval and output validation. Empty selections expose no operations.
- * Discovery is sequential and cancellation follows the caller's signal.
- */
-export declare const accountOperations: <Account extends {
-    readonly id: string;
-}>(accounts: readonly Account[], discover: (account: Account) => Promise<Operations>, options: {
-    readonly signal: AbortSignal;
-}) => Promise<{
-    queries: {
-        [k: string]: Operation<{
-            readonly accountId: string;
-            readonly input: unknown;
-        }, unknown, "query", import("../index.js").AppContext>;
-    };
-    mutations: {
-        [k: string]: Operation<{
-            readonly accountId: string;
-            readonly input: unknown;
-        }, unknown, "mutation", import("../index.js").AppContext>;
-    };
-} | {
-    dynamicTools: {
-        list: () => Effect.Effect<{
-            readonly name: string;
-            readonly description: string;
-            readonly inputSchema: {
-                readonly [x: string]: Schema.Json;
-            };
-            readonly _meta?: {
-                readonly [x: string]: Schema.Json;
-            };
-            readonly title?: string;
-            readonly outputSchema?: {
-                readonly [x: string]: Schema.Json;
-            };
-            readonly annotations?: {
-                readonly title?: string;
-                readonly readOnlyHint?: boolean;
-                readonly destructiveHint?: boolean;
-                readonly idempotentHint?: boolean;
-                readonly openWorldHint?: boolean;
-            };
-            readonly schedules?: readonly {
-                readonly name: string;
-                readonly timing: {
-                    readonly kind: "interval";
-                    readonly milliseconds: number;
-                } | {
-                    readonly kind: "cron";
-                    readonly calendar: {
-                        readonly expression: string;
-                        readonly timezone: string;
-                    };
-                };
-                readonly input: Schema.Json;
-            }[];
-            readonly readOnly?: boolean;
-        }[], unknown, never>;
-        summaries: () => Effect.Effect<{
-            readonly name: string;
-            readonly description: string;
-            readonly title?: string;
-            readonly annotations?: {
-                readonly title?: string;
-                readonly readOnlyHint?: boolean;
-                readonly destructiveHint?: boolean;
-                readonly idempotentHint?: boolean;
-                readonly openWorldHint?: boolean;
-            };
-            readonly schedules?: readonly {
-                readonly name: string;
-                readonly timing: {
-                    readonly kind: "interval";
-                    readonly milliseconds: number;
-                } | {
-                    readonly kind: "cron";
-                    readonly calendar: {
-                        readonly expression: string;
-                        readonly timezone: string;
-                    };
-                };
-                readonly input: Schema.Json;
-            }[];
-            readonly readOnly?: boolean;
-        }[], unknown, never>;
-        describe: (name: string) => Effect.Effect<{
-            readonly name: string;
-            readonly description: string;
-            readonly inputSchema: {
-                readonly [x: string]: Schema.Json;
-            };
-            readonly _meta?: {
-                readonly [x: string]: Schema.Json;
-            };
-            readonly title?: string;
-            readonly outputSchema?: {
-                readonly [x: string]: Schema.Json;
-            };
-            readonly annotations?: {
-                readonly title?: string;
-                readonly readOnlyHint?: boolean;
-                readonly destructiveHint?: boolean;
-                readonly idempotentHint?: boolean;
-                readonly openWorldHint?: boolean;
-            };
-            readonly schedules?: readonly {
-                readonly name: string;
-                readonly timing: {
-                    readonly kind: "interval";
-                    readonly milliseconds: number;
-                } | {
-                    readonly kind: "cron";
-                    readonly calendar: {
-                        readonly expression: string;
-                        readonly timezone: string;
-                    };
-                };
-                readonly input: Schema.Json;
-            }[];
-            readonly readOnly?: boolean;
-        } | undefined, unknown, never>;
-        resolve: (name: string) => Effect.Effect<AppOperation<unknown, unknown> | undefined, unknown, never>;
-    };
-    queries: {
-        [k: string]: Operation<{
-            readonly accountId: string;
-            readonly input: unknown;
-        }, unknown, "query", import("../index.js").AppContext>;
-    };
-    mutations: {
-        [k: string]: Operation<{
-            readonly accountId: string;
-            readonly input: unknown;
-        }, unknown, "mutation", import("../index.js").AppContext>;
-    };
-}>;
-export {};

package/types/apps/src/implementation/dynamic-tools.d.ts

@@ -1,8 +0,0 @@
-import { HostedTool } from "../contracts/host.js";
-import type { DynamicTools } from "../contracts/dynamic-tools.js";
-import { type OperationDeclaration } from "./operations.js";
-/** Declare metadata discovery separately from executable resolution. Names are fully qualified. */
-export declare const dynamicTools: (source: {
-    readonly list: () => Promise<readonly HostedTool[]>;
-    readonly resolve: (name: string) => Promise<OperationDeclaration<"query" | "mutation"> | undefined>;
-}) => DynamicTools;