apps 0.0.1-beta.4 → 0.0.1-beta.6

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

@@ -0,0 +1,225 @@
+/**
+ * Read a live router tree into tools, routers and router skills. A nested dynamic router that fails
+ * is reported on its own entry; the root failing fails the read, as a single-source app would.
+ */
+import { Effect, Schema } from "effect";
+import { HostDeclarationInvalid, HostEvaluationFailed, type HostRouterError } from "../contracts/host.js";
+import { McpError } from "../contracts/mcp.js";
+import type { AppOperation } from "../contracts/operations.js";
+import type { AppRouter, DynamicRouter, RouterMeta } from "../contracts/router.js";
+import { SkillLoadFailed } from "../contracts/skills.js";
+import type { OperationSchedule } from "../contracts/schedules.js";
+/**
+ * Keep only a failure's safe fields. Anything unrecognized becomes an evaluation failure with the
+ * error's name and bounded message, with the given account secrets replaced.
+ */
+export declare const safeFailure: (error: unknown, secrets: readonly string[]) => HostRouterError;
+/**
+ * Router skills are named `tools` for the root and `tools-<path>` below it, so a router's
+ * instructions never take an authored skill's name by accident.
+ */
+export declare const routerSkillPrefix = "tools";
+/**
+ * The skill name for a router path. A path of lowercase letters and digits is spelled out:
+ * `issues.open` is `tools-issues-open`. Any other path, or one too long, is a readable slug
+ * followed by a hash of the exact path, such as `tools-issues-list-0123456789`. Plain segments
+ * start with a letter and a hash is all digits, so the two forms never meet, and paths that slug
+ * alike, such as `issues_list` and `issues.list`, get different names.
+ */
+export declare const routerSkillName: (path: string) => string;
+/** A declared operation's catalog entry without schemas. `router` is its owning router's path. */
+export declare const operationSummary: (name: string, router: string, operation: AppOperation, schedules?: readonly OperationSchedule[]) => 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;
+    readonly router?: string;
+    readonly tags?: readonly string[];
+}, HostDeclarationInvalid, never>;
+/** A declared operation's full description, including rendered schemas. */
+export declare const operationDescription: (name: string, router: string, operation: AppOperation, schedules?: readonly OperationSchedule[]) => 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 annotations?: {
+        readonly title?: string;
+        readonly readOnlyHint?: boolean;
+        readonly destructiveHint?: boolean;
+        readonly idempotentHint?: boolean;
+        readonly openWorldHint?: boolean;
+    };
+    readonly outputSchema?: {
+        readonly [x: string]: Schema.Json;
+    };
+    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;
+    readonly router?: string;
+    readonly tags?: readonly string[];
+}, HostDeclarationInvalid, never>;
+/**
+ * A dynamic router over operations already discovered, such as an eager OpenAPI document or a
+ * stdio server. Upstream names can contain dots, which static router keys cannot.
+ */
+export declare const fixedRouter: (operations: Readonly<Record<string, AppOperation>>, meta?: RouterMeta) => DynamicRouter;
+export interface CatalogOptions {
+    /** Omit schemas. */
+    readonly summary: boolean;
+    /** Account secrets that a failure's message must not reveal. */
+    readonly secrets: readonly string[];
+    /** Only these full tool names. Routers with none of them are not read. */
+    readonly wanted?: ReadonlySet<string>;
+    /** Schedules that target a declared operation, by full name. */
+    readonly schedules: (name: string) => readonly OperationSchedule[];
+    /**
+     * Only declared operations that have schedules. Schedules never target dynamic routers, and
+     * their catalogs can be expensive to discover, so none is read.
+     */
+    readonly scheduled?: true;
+}
+/**
+ * Read a router tree. Every nested router is listed, for grouping; the root only when it has
+ * metadata. A nested dynamic source that fails is reported on its router's entry.
+ */
+export declare const readCatalog: (root: AppRouter | DynamicRouter | undefined, options: CatalogOptions) => Effect.Effect<{
+    tools: ({
+        readonly name: string;
+        readonly description: string;
+        readonly inputSchema: {
+            readonly [x: string]: Schema.Json;
+        };
+        readonly _meta?: {
+            readonly [x: string]: Schema.Json;
+        };
+        readonly title?: string;
+        readonly annotations?: {
+            readonly title?: string;
+            readonly readOnlyHint?: boolean;
+            readonly destructiveHint?: boolean;
+            readonly idempotentHint?: boolean;
+            readonly openWorldHint?: boolean;
+        };
+        readonly outputSchema?: {
+            readonly [x: string]: Schema.Json;
+        };
+        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;
+        readonly router?: string;
+        readonly tags?: readonly string[];
+    } | {
+        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;
+        readonly router?: string;
+        readonly tags?: readonly string[];
+    })[];
+    routers: {
+        readonly path: string;
+        readonly error?: import("../index.js").ProviderError | SkillLoadFailed | McpError | HostDeclarationInvalid | HostEvaluationFailed;
+        readonly description?: string;
+        readonly title?: string;
+        readonly tags?: {
+            readonly [x: string]: string;
+        };
+        readonly icons?: readonly {
+            readonly src: string;
+            readonly mimeType?: string;
+            readonly sizes?: readonly string[];
+            readonly theme?: "light" | "dark";
+        }[];
+        readonly skill?: string;
+    }[];
+}, import("../index.js").ProviderError | SkillLoadFailed | McpError | HostDeclarationInvalid | HostEvaluationFailed, never>;
+/**
+ * One skill for each router with instructions. Skills and tools fail independently: a dynamic
+ * router whose metadata cannot be read, including the root, contributes no skill and does not
+ * fail the others. Metadata comes through each source's catalog cache, like a tool listing.
+ */
+export declare const routerSkills: (root: AppRouter | DynamicRouter | undefined) => Effect.Effect<{
+    readonly name: string;
+    readonly description: string;
+    readonly files: readonly {
+        readonly path: string;
+        readonly content: string;
+    }[];
+    readonly license?: string;
+    readonly compatibility?: string;
+    readonly metadata?: {
+        readonly [x: string]: string;
+    };
+    readonly "allowed-tools"?: string;
+}[], never, never>;

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/storage.d.ts

@@ -1,10 +1,12 @@
-import { type DatabaseSession } from "../../../app-data/src/index.js";
+import { type DatabaseSession, type reservedFieldNames } from "../../../app-data/src/index.js";
+type ReservedFieldName = (typeof reservedFieldNames)[number];
 import { type AppStorage } from "../contracts/storage.js";
 import type { DatabaseDefinition, Database, Table, Tables } from "../contracts/storage.js";
 import { type Fields } from "./schema.js";
 export type { DatabaseDefinition, Database, DatabaseReader, Table, Tables, RowOf, } from "../contracts/storage.js";
-/** Declare scalar columns using the same schemas as operation inputs. */
-export declare const table: <const F extends Fields>(fields: F) => Table<F>;
+/** Declare scalar columns using the same schemas as operation inputs. The host adds `id`,
+ * `createdAt` and `updatedAt` to every row, so tables cannot declare those names. */
+export declare const table: <const F extends Fields & { readonly [K in ReservedFieldName]?: never; }>(fields: F) => Table<F>;
 /** Build a fresh Promise database facade for one authorized invocation. */
 export declare const authorDatabase: <T extends Tables>(tables: T, session: DatabaseSession, signal: AbortSignal, writable: boolean) => Database<T>;
 /** Declare storage independently of handlers; the host binds each invocation's database. */

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

@@ -26,4 +26,4 @@ export declare const dispatchWebhook: <Context extends {
         readonly [x: string]: string;
     };
     readonly body: string;
-}, HostDeclarationInvalid | HostOperationNotFound | HostOperationFailed | HostInputInvalid | HostOutputInvalid, never>;
+}, HostOperationNotFound | HostInputInvalid | HostOutputInvalid | HostDeclarationInvalid | HostOperationFailed, never>;

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

@@ -2,7 +2,15 @@
 import { Effect } from "effect";
 import type { AppDefinition } from "../contracts/app.js";
 import { WorkflowFailure, type WorkflowContext, type WorkflowExecution, type WorkflowStepContext } from "../contracts/workflows.js";
-/** Preserve typed failures and cancellation; authored exception text never leaves the app. */
-export declare const workflowSafe: <A>(work: Effect.Effect<A, unknown>) => Effect.Effect<A, WorkflowFailure>;
+/**
+ * Preserve typed failures and cancellation. Other errors keep their name and bounded message,
+ * with the given account secrets replaced.
+ */
+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">, fresh: (stepId: string, signal: AbortSignal) => Effect.Effect<WorkflowStepContext, WorkflowFailure>, signal: AbortSignal) => Effect.Effect<WorkflowContext>;
+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;
+    readonly secrets: readonly string[];
+}, WorkflowFailure>, signal: AbortSignal) => Effect.Effect<WorkflowContext>;

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-PYUYJRSK.js

@@ -1,93 +0,0 @@
-import {
-  decoderOf
-} from "./chunk-WFSQXYUT.js";
-import {
-  Effect_exports
-} from "./chunk-FW5HBOIK.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-SWPD52J7.js

@@ -1,35 +0,0 @@
-import {
-  Schema_exports
-} from "./chunk-FW5HBOIK.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/js/chunk-W7D7WVSY.js

@@ -1,18 +0,0 @@
-import {
-  AccountId
-} from "./chunk-SATWJKN6.js";
-import {
-  Schema_exports
-} from "./chunk-FW5HBOIK.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/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>;
-}