apps 0.0.1-beta.4 → 0.0.1-beta.40

package/js/chunk-4TLZGG4B.js

@@ -0,0 +1,729 @@
+import {
+  skillFromFiles
+} from "./chunk-CQD3WSYH.js";
+import {
+  joinPath,
+  mergeMeta
+} from "./chunk-6KABJTDO.js";
+import {
+  isShortenedUpstream,
+  parseProviderError,
+  providerError
+} from "./chunk-EM4UL26F.js";
+import {
+  ApiErrorResponse,
+  HostDeclarationInvalid,
+  HostEvaluationFailed,
+  HostedRouter,
+  HostedTool,
+  HostedToolSummary,
+  McpCredentialsUnverified,
+  McpError,
+  McpError2,
+  SkillLoadFailed as SkillLoadFailed2
+} from "./chunk-OTCLXFLL.js";
+import {
+  CacheError,
+  FailureCode,
+  FailureFieldName,
+  FetchOptionUnsupported,
+  NetworkRefused,
+  maxFailureFieldLength,
+  maxFailureFields,
+  maxFailureMessageLength,
+  maxUpstreamMessageLength
+} from "./chunk-P7MGDPFD.js";
+import {
+  SkillLoadFailed,
+  skillFormatLimits
+} from "./chunk-UOZMSUJ2.js";
+import {
+  jsonSchemaDocument
+} from "./chunk-GHXRRFZA.js";
+import {
+  AccountId,
+  HttpUrl,
+  JsonObject
+} from "./chunk-YQ35E7KS.js";
+import {
+  Cause_exports,
+  Effect_exports,
+  Match_exports,
+  Option_exports,
+  Predicate_exports,
+  Redacted_exports,
+  Result_exports,
+  Schema_exports
+} from "./chunk-MXDKXAY4.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,
+  /** OpenAPI 3.2's `querystring` is the whole query string, serialized from one `content` value. */
+  in: Schema_exports.Literals(["path", "query", "querystring", "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", "QUERY"]),
+  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)),
+  /** The operation's OpenAPI tags, shown to agents as labels within its router. */
+  tags: Schema_exports.optionalKey(Schema_exports.Array(Schema_exports.NonEmptyString)),
+  input: JsonObject,
+  outputSchema: Schema_exports.optionalKey(JsonObject),
+  errorResponses: Schema_exports.optionalKey(Schema_exports.Array(OpenapiErrorResponse))
+});
+var isOpenapiReadMethod = (method) => method === "GET" || method === "HEAD" || method === "OPTIONS" || method === "QUERY";
+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 OpenapiFailedOperation = Schema_exports.Struct({
+  method: OpenapiOperation.fields.method,
+  path: Schema_exports.String
+});
+var OpenapiMediaType = Schema_exports.String.check(
+  Schema_exports.isMaxLength(128),
+  Schema_exports.isPattern(/^[\w!#$&^.+-]+\/[\w!#$&^.+-]+$/u)
+);
+var OpenapiError = class extends Schema_exports.TaggedError()("OpenapiError", {
+  reason: Schema_exports.Literals(["invalid_definition", "invalid_input", "request"]),
+  status: Schema_exports.optional(Schema_exports.Number),
+  /** Absent only when the definition itself could not be read. */
+  operation: Schema_exports.optional(OpenapiFailedOperation),
+  contentType: Schema_exports.optional(OpenapiMediaType),
+  /** The response's `content-length`, when it declared one. */
+  bytes: Schema_exports.optional(Schema_exports.Int.check(Schema_exports.isGreaterThanOrEqualTo(0)))
+}) {
+};
+var defaultOpenapiResponseLimits = {
+  maxBodyBytes: 16777216,
+  readTimeoutMs: 3e4
+};
+var isOpenapiJsonSequence = (type) => /^application\/(?:x-)?(?:ndjson|jsonl|jsonlines|json-seq)\s*(?:;|$)/i.test(type);
+var isOpenapiTextMedia = (type) => isOpenapiJsonSequence(type) || /^(?:text\/|application\/(?:[\w.-]+\+)?(?:json|xml)|application\/(?:javascript|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") && !isOpenapiJsonSequence(type) ? "json" : type === "application/x-www-form-urlencoded" ? "form" : type === "multipart/form-data" ? "multipart" : isOpenapiTextMedia(type) ? "text" : "binary";
+
+// src/contracts/openapi-compile.ts
+var OpenapiCompileErrorCode = Schema_exports.Literals([
+  "server_protocol",
+  "server_url",
+  "external_reference",
+  "circular_reference",
+  "schema_keyword",
+  "schema_reference",
+  "missing_component",
+  "openapi_version",
+  "auth_helper",
+  "auth_missing",
+  "operation_path",
+  "operation_method",
+  "duplicate_operation",
+  "server_missing",
+  "multiple_hosts",
+  "parameter_encoding",
+  "parameter_style",
+  "request_body",
+  "combined_oauth",
+  "auth_method",
+  "event_stream",
+  "input_schema",
+  "no_operations",
+  "no_supported_operations",
+  "invalid_document",
+  "source_generation",
+  "authoring_reference"
+]);
+var OpenapiSkippedOperation = Schema_exports.Struct({
+  /** The tool name the operation would have; reading that tool reports why it is missing. */
+  name: Schema_exports.String,
+  /** The HTTP method, such as `GET`. */
+  method: Schema_exports.String,
+  /** The path as the definition declares it. */
+  path: Schema_exports.String,
+  code: OpenapiCompileErrorCode,
+  reason: Schema_exports.String
+});
+var listedReasons = 8;
+var reasonLength = 240;
+var cut = (text) => text.length <= reasonLength ? text : `${text.slice(0, reasonLength - 1)}\u2026`;
+var compileMessage = (error) => {
+  const skipped = error.skipped ?? [];
+  if (skipped.length === 0) return error.reason;
+  const groups = /* @__PURE__ */ new Map();
+  for (const operation of skipped) {
+    const key = JSON.stringify([operation.code, operation.reason]);
+    const group = groups.get(key);
+    if (group === void 0) groups.set(key, { first: operation, count: 1 });
+    else group.count++;
+  }
+  const example = ({ first, count }) => `${first.method} ${first.path}${count > 1 ? ` and ${count - 1} more` : ""}`;
+  const [only, ...others] = groups.values();
+  if (only !== void 0 && others.length === 0 && only.first.code === error.code && only.first.reason === error.reason)
+    return `${error.reason} Left out: ${example(only)}.`;
+  const listed = [...groups.values()].slice(0, listedReasons);
+  const rest = groups.size - listed.length;
+  return `${error.reason} Left out: ${listed.map(
+    (group) => `${example(group)} (${group.first.code}: ${cut(group.first.reason.replace(/\.$/, ""))})`
+  ).join("; ")}${rest > 0 ? `; and ${rest} other reasons` : ""}.`;
+};
+var OpenapiCompileError = class extends Schema_exports.TaggedError()(
+  "OpenapiCompileError",
+  {
+    code: OpenapiCompileErrorCode,
+    reason: Schema_exports.String,
+    skipped: Schema_exports.optionalKey(Schema_exports.Array(OpenapiSkippedOperation)),
+    origins: Schema_exports.optionalKey(Schema_exports.Array(Schema_exports.String))
+  }
+) {
+  get message() {
+    return compileMessage(this);
+  }
+};
+
+// src/implementation/failure-detail.ts
+var cacheMessages = {
+  capacity: "A cache key, value or batch exceeded the app cache's size limits.",
+  invalid: "The app made a cache request the app cache could not accept.",
+  unavailable: "The app cache is not available on this host.",
+  storage: "The app cache failed to complete the operation.",
+  timeout: "The app cache did not respond in time."
+};
+var mcpStages = {
+  connect: "connecting",
+  transport: "connecting",
+  discover: "listing its tools",
+  schema: "reading a tool's schema",
+  call: "calling a tool"
+};
+var mcpMessage = ({ phase, reason, status }) => {
+  const stage = mcpStages[phase];
+  return Match_exports.value(reason).pipe(
+    Match_exports.when("timeout", () => `The MCP server did not respond in time while ${stage}.`),
+    Match_exports.when("unauthorized", () => `The MCP server rejected the credentials while ${stage}.`),
+    Match_exports.when(
+      "invalid_response",
+      () => `The MCP server returned a response Executor could not use while ${stage}, such as an unreadable message or an address on another origin.`
+    ),
+    Match_exports.when("invalid_input", () => "The MCP server URL or connection settings are invalid."),
+    // Only a transport failure has no answer from the server; a JSON-RPC error is an answer.
+    Match_exports.when(
+      "request",
+      () => status !== void 0 ? `The MCP server answered HTTP ${status} while ${stage}.` : phase === "transport" ? `Executor could not reach the MCP server while ${stage}.` : `The request to the MCP server failed while ${stage}.`
+    ),
+    Match_exports.exhaustive
+  );
+};
+var unverifiedMessage = ({ anonymous }) => anonymous === "answered" ? "This MCP server answers without credentials, so Executor can't check this account. A refused key will show up when a tool is called." : `The MCP server accepted the credentials, but the same check without them failed, so Executor can't tell whether it requires them. ${Schema_exports.is(McpError)(anonymous) ? mcpMessage(anonymous) : anonymous.status === void 0 ? "The MCP server could not answer the request." : `The MCP server answered HTTP ${anonymous.status}.`}`;
+var minimumSecretLength = 6;
+var secretValues = (value, found) => {
+  if (typeof value === "string") {
+    if (value.length >= minimumSecretLength) found.add(value);
+  } else if (Array.isArray(value)) for (const item of value) secretValues(item, found);
+  else if (Predicate_exports.isObject(value))
+    for (const item of Object.values(value)) secretValues(item, found);
+  return found;
+};
+var accountFieldSecrets = (accounts) => {
+  const found = /* @__PURE__ */ new Set();
+  if (Predicate_exports.isObject(accounts)) {
+    for (const slot of Object.values(accounts))
+      for (const account of Array.isArray(slot) ? slot : [slot])
+        if (Predicate_exports.hasProperty(account, "fields")) secretValues(account.fields, found);
+  }
+  return [...found].sort((a, b) => b.length - a.length);
+};
+var accountSecrets = (accounts) => accountFieldSecrets(Redacted_exports.value(accounts));
+var replaceSecrets = (text, secrets) => {
+  let redacted = text;
+  for (const secret of secrets) redacted = redacted.split(secret).join("[redacted]");
+  return redacted;
+};
+var bound = (text, maximum) => text.length <= maximum ? text : `${text.slice(0, maximum - 1)}\u2026`;
+var boundText = (text, secrets, maximum) => bound(replaceSecrets(text, secrets), maximum);
+var replaceSecretStart = (text, secrets) => {
+  let longest = 0;
+  for (const secret of secrets)
+    for (let length = Math.min(secret.length - 1, text.length); length > longest; length--)
+      if (text.endsWith(secret.slice(0, length))) {
+        longest = length;
+        break;
+      }
+  return longest === 0 ? text : `${text.slice(0, -longest)}[redacted]`;
+};
+var boundFailureMessage = (message, secrets) => boundText(message, secrets, maxFailureMessageLength);
+var redactUpstream = (upstream, secrets) => {
+  if (upstream?.message === void 0) return upstream;
+  const message = isShortenedUpstream(upstream.message) ? `${replaceSecretStart(replaceSecrets(upstream.message.slice(0, -1), secrets), secrets)}\u2026` : replaceSecrets(upstream.message, secrets);
+  return { code: upstream.code, message: bound(message, maxUpstreamMessageLength) };
+};
+var leavingProviderError = (error, secrets, phase) => providerError({
+  ...error,
+  phase: error.phase ?? phase,
+  upstream: redactUpstream(error.upstream, secrets)
+});
+var parseMcpError = (error, secrets) => Schema_exports.decodeUnknownOption(McpError)(error).pipe(
+  Option_exports.map(({ phase, reason, status, upstream, session }) => {
+    const stated = redactUpstream(upstream, secrets);
+    return new McpError2({
+      phase,
+      reason,
+      ...status === void 0 ? {} : { status },
+      ...stated === void 0 ? {} : { upstream: stated },
+      ...session === void 0 ? {} : { session }
+    });
+  })
+);
+var parseSkillLoadFailed = (error) => Schema_exports.decodeUnknownOption(SkillLoadFailed)(error).pipe(
+  Option_exports.map(
+    ({ reason, message, status, missing }) => new SkillLoadFailed2({
+      reason,
+      ...message ? { message } : {},
+      ...status === void 0 ? {} : { status },
+      ...missing === void 0 ? {} : { missing }
+    })
+  )
+);
+var errorName = (error) => (error.name.length > 0 ? error.name : "Error").slice(0, 128);
+var ownCode = (error, secrets) => Predicate_exports.hasProperty(error, "code") && Schema_exports.is(FailureCode)(error.code) && error.code !== "" ? boundText(error.code, secrets, 128) : void 0;
+var reservedFields = /* @__PURE__ */ new Set(["name", "message", "stack", "cause", "_tag"]);
+var ownFields = (error, code, secrets) => {
+  const fields = {};
+  let count = 0;
+  for (const [key, value] of Object.entries(error)) {
+    if (count === maxFailureFields) break;
+    if (reservedFields.has(key) || key === "code" && code !== void 0) continue;
+    if (!Schema_exports.is(FailureFieldName)(key)) continue;
+    if (typeof value === "string") fields[key] = boundText(value, secrets, maxFailureFieldLength);
+    else if (typeof value === "boolean" || typeof value === "number" && Number.isFinite(value))
+      fields[key] = value;
+    else continue;
+    count++;
+  }
+  return count === 0 ? void 0 : fields;
+};
+var ownMessage = (error) => {
+  const cause = error.cause;
+  const suffix = cause instanceof Error && cause.message.length > 0 ? ` (caused by ${errorName(cause)}: ${cause.message})` : "";
+  return error.message.length > 0 ? `${error.message}${suffix}` : void 0;
+};
+var describeFailure = (error) => error instanceof Error ? `${errorName(error)}: ${ownMessage(error) ?? "(no message)"}` : typeof error === "string" ? error : `A non-Error ${error === null ? "null" : typeof error} value was thrown`;
+var openapiFailureMessage = (error) => {
+  const operation = error.operation === void 0 ? "The API request" : `${error.operation.method} ${error.operation.path}`;
+  if (error.reason === "invalid_definition")
+    return "The API's OpenAPI definition for this operation is invalid.";
+  if (error.reason === "invalid_input")
+    return error.operation === void 0 ? "The input could not be encoded as a request for this API operation." : `The input could not be encoded as a request for ${operation}.`;
+  if (error.status === void 0) return `${operation} failed before a response arrived.`;
+  const shape = [error.contentType, error.bytes === void 0 ? void 0 : `${error.bytes} bytes`].filter((part) => part !== void 0).join(", ");
+  const response = `${operation} responded with HTTP ${error.status}${shape === "" ? "" : ` (${shape})`}`;
+  return error.status >= 200 && error.status < 300 ? `${response}, but its body could not be read within the response limits.` : `${response}, which matches no error with a message in the API's OpenAPI document.`;
+};
+var failureDetail = (error, secrets) => {
+  if (Schema_exports.is(CacheError)(error))
+    return {
+      source: "storage",
+      errorName: "CacheError",
+      code: error.reason,
+      message: cacheMessages[error.reason]
+    };
+  if (Schema_exports.is(OpenapiError)(error))
+    return {
+      source: "service",
+      errorName: "OpenapiError",
+      code: error.reason,
+      message: boundFailureMessage(openapiFailureMessage(error), secrets)
+    };
+  if (Schema_exports.is(McpError)(error))
+    return {
+      source: "service",
+      errorName: "McpError",
+      code: error.reason,
+      message: mcpMessage(error)
+    };
+  if (Schema_exports.is(McpCredentialsUnverified)(error))
+    return {
+      source: "service",
+      errorName: "McpCredentialsUnverified",
+      code: error.anonymous === "answered" ? "anonymous_access" : error.anonymous.reason,
+      message: unverifiedMessage(error)
+    };
+  if (Schema_exports.is(OpenapiCompileError)(error))
+    return {
+      source: "app",
+      errorName: "OpenapiCompileError",
+      code: error.code,
+      message: boundFailureMessage(error.message, secrets)
+    };
+  if (Schema_exports.is(NetworkRefused)(error))
+    return {
+      source: "app",
+      errorName: "NetworkRefused",
+      code: error.refusal.reason,
+      message: boundFailureMessage(error.message, secrets)
+    };
+  if (Schema_exports.is(FetchOptionUnsupported)(error))
+    return {
+      source: "app",
+      errorName: "FetchOptionUnsupported",
+      code: error.option,
+      message: boundFailureMessage(error.message, secrets)
+    };
+  if (error instanceof Error) {
+    const code = ownCode(error, secrets);
+    const fields = ownFields(error, code, secrets);
+    return {
+      source: "app",
+      errorName: errorName(error),
+      ...code === void 0 ? {} : { code },
+      message: boundFailureMessage(
+        ownMessage(error) ?? `${errorName(error)} was thrown without a message.`,
+        secrets
+      ),
+      ...fields === void 0 ? {} : { fields }
+    };
+  }
+  if (typeof error === "string")
+    return { source: "app", errorName: "string", message: boundFailureMessage(error, secrets) };
+  return {
+    source: "app",
+    errorName: typeof error,
+    message: `A non-Error ${error === null ? "null" : typeof error} value was thrown.`
+  };
+};
+
+// src/implementation/router-catalog.ts
+var safeFailure = (error, secrets) => {
+  const provider = parseProviderError(error);
+  if (Option_exports.isSome(provider)) return leavingProviderError(provider.value, secrets, "discover");
+  const skills = parseSkillLoadFailed(error);
+  if (Option_exports.isSome(skills)) return skills.value;
+  const mcp = parseMcpError(error, secrets);
+  if (Option_exports.isSome(mcp)) return mcp.value;
+  if (Schema_exports.is(HostDeclarationInvalid)(error)) return error;
+  return new HostEvaluationFailed(failureDetail(error, secrets));
+};
+var sourced = (work, secrets) => Effect_exports.suspend(work).pipe(
+  Effect_exports.catchCause(
+    (cause) => Cause_exports.hasInterrupts(cause) ? Effect_exports.interrupt : Effect_exports.fail(safeFailure(Cause_exports.squash(cause), secrets))
+  )
+);
+var routerMeta = (node, secrets) => node.kind === "router" ? Effect_exports.succeed(node.meta) : node.meta === void 0 ? Effect_exports.succeed(node.overrides) : sourced(node.meta, secrets).pipe(Effect_exports.map((meta) => mergeMeta(meta, node.overrides)));
+var routerSkillPrefix = "tools";
+var plainSegment = /^[a-z][a-z0-9]*$/;
+var pathHash = (path) => {
+  let hash = 2166136261;
+  for (let index = 0; index < path.length; index++)
+    hash = Math.imul(hash ^ path.charCodeAt(index), 16777619) >>> 0;
+  return hash.toString().padStart(10, "0");
+};
+var routerSkillName = (path) => {
+  if (path === "") return routerSkillPrefix;
+  const segments = path.split(".");
+  const plain = [routerSkillPrefix, ...segments].join("-");
+  if (segments.every((segment) => plainSegment.test(segment)) && plain.length <= skillFormatLimits.nameCharacters)
+    return plain;
+  const hash = pathHash(path);
+  const slug = path.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, skillFormatLimits.nameCharacters - routerSkillPrefix.length - hash.length - 2).replace(/^-+|-+$/g, "");
+  return [routerSkillPrefix, slug, hash].filter((part) => part !== "").join("-");
+};
+var entry = (path, meta, error) => Schema_exports.decodeUnknownEffect(HostedRouter)({
+  path,
+  ...meta?.title === void 0 ? {} : { title: meta.title },
+  ...meta?.description === void 0 ? {} : { description: meta.description },
+  ...meta?.icons === void 0 ? {} : { icons: meta.icons },
+  ...meta?.tags === void 0 ? {} : { tags: meta.tags },
+  ...meta?.instructions === void 0 ? {} : { skill: routerSkillName(path) },
+  ...error === void 0 ? {} : { error }
+}).pipe(Effect_exports.mapError(() => new HostDeclarationInvalid()));
+var invalid = (work) => work.pipe(
+  Effect_exports.catchCause(
+    (cause) => Cause_exports.hasInterrupts(cause) ? Effect_exports.interrupt : Effect_exports.fail(new HostDeclarationInvalid())
+  )
+);
+var summaryFields = (name, router, operation, schedules) => {
+  const readOnly = operation.kind === "query";
+  return {
+    name,
+    ...router === "" ? {} : { router },
+    ...schedules === void 0 ? {} : { schedules },
+    description: operation.description ?? `${readOnly ? "Query" : "Mutate"} ${name}`,
+    ...operation.title === void 0 ? {} : { title: operation.title },
+    readOnly,
+    annotations: { ...operation.annotations, readOnlyHint: readOnly }
+  };
+};
+var operationSummary = (name, router, operation, schedules) => invalid(
+  Schema_exports.decodeUnknownEffect(HostedToolSummary)(
+    summaryFields(name, router, operation, schedules)
+  )
+);
+var operationDescription = (name, router, operation, schedules) => invalid(
+  Effect_exports.gen(function* () {
+    return yield* Schema_exports.decodeUnknownEffect(HostedTool)({
+      ...summaryFields(name, router, operation, schedules),
+      inputSchema: yield* jsonSchemaDocument(operation.input),
+      ...operation.output === void 0 ? operation.outputSchema === void 0 ? {} : { outputSchema: operation.outputSchema } : { outputSchema: yield* jsonSchemaDocument(operation.output) },
+      ...operation._meta === void 0 ? {} : { _meta: operation._meta }
+    });
+  })
+);
+var fixedRouter = (operations, meta) => ({
+  kind: "dynamic",
+  ...meta === void 0 ? {} : { meta: () => Effect_exports.succeed(meta) },
+  list: () => Effect_exports.forEach(
+    Object.entries(operations),
+    ([name, operation]) => operationDescription(name, "", operation)
+  ),
+  summaries: () => Effect_exports.forEach(
+    Object.entries(operations),
+    ([name, operation]) => operationSummary(name, "", operation)
+  ),
+  describe: (name) => {
+    const operation = Object.hasOwn(operations, name) ? operations[name] : void 0;
+    return operation === void 0 ? Effect_exports.succeed(void 0) : operationDescription(name, "", operation);
+  },
+  resolve: (name) => Effect_exports.succeed(Object.hasOwn(operations, name) ? operations[name] : void 0)
+});
+var within = (wanted, path) => [...wanted].flatMap(
+  (name) => path === "" ? [name] : name.startsWith(`${path}.`) ? [name.slice(path.length + 1)] : []
+);
+var readCatalog = (root, options) => Effect_exports.gen(function* () {
+  const tools = [];
+  const routers = [];
+  const { wanted, secrets } = options;
+  const readSource = (source, path, relative) => Effect_exports.gen(function* () {
+    const describe = source.describe;
+    const [meta, listed] = yield* Effect_exports.all(
+      [
+        routerMeta(source, secrets),
+        options.summary && source.summaries !== void 0 ? sourced(source.summaries, secrets) : relative !== void 0 && describe !== void 0 ? sourced(
+          () => Effect_exports.forEach(relative, (name) => describe(name), {
+            concurrency: "unbounded"
+          }),
+          secrets
+        ).pipe(Effect_exports.map((tools2) => tools2.filter((tool) => tool !== void 0))) : sourced(source.list, secrets)
+      ],
+      { concurrency: "unbounded" }
+    );
+    const parsed = yield* Schema_exports.decodeUnknownEffect(
+      Schema_exports.Array(options.summary ? HostedToolSummary : HostedTool)
+    )(listed).pipe(Effect_exports.mapError(() => new HostDeclarationInvalid()));
+    const names = /* @__PURE__ */ new Set();
+    const found = [];
+    for (const tool of parsed) {
+      if (names.has(tool.name)) return yield* new HostDeclarationInvalid();
+      names.add(tool.name);
+      if (relative !== void 0 && !relative.includes(tool.name)) continue;
+      const readOnly = tool.readOnly === true;
+      found.push({
+        ...tool,
+        name: joinPath(path, tool.name),
+        ...path === "" ? {} : { router: path },
+        readOnly,
+        annotations: { ...tool.annotations, readOnlyHint: readOnly }
+      });
+    }
+    return { meta, found };
+  });
+  const include = (source, path, relative) => Effect_exports.gen(function* () {
+    if (path === "") {
+      const { meta, found } = yield* readSource(source, path, relative);
+      tools.push(...found);
+      return { meta, error: void 0 };
+    }
+    const result = yield* Effect_exports.result(readSource(source, path, relative));
+    if (Result_exports.isFailure(result)) return { meta: source.overrides, error: result.failure };
+    tools.push(...result.success.found);
+    return { meta: result.success.meta, error: void 0 };
+  });
+  const visit = (node, path) => Effect_exports.gen(function* () {
+    if (path !== "" || wanted === void 0 && node.meta !== void 0)
+      routers.push(yield* entry(path, node.meta));
+    for (const [key, child] of Object.entries(node.children)) {
+      const name = joinPath(path, key);
+      switch (child.kind) {
+        case "query":
+        case "mutation":
+          if (options.scheduled === true && options.schedules(name).length === 0) break;
+          if (wanted === void 0 || wanted.has(name))
+            tools.push(
+              options.summary ? yield* operationSummary(name, path, child, options.schedules(name)) : yield* operationDescription(name, path, child, options.schedules(name))
+            );
+          break;
+        case "router":
+          if (wanted === void 0 || within(wanted, name).length > 0)
+            yield* visit(child, name);
+          break;
+        case "dynamic": {
+          if (options.scheduled === true) break;
+          const relative = wanted === void 0 ? void 0 : within(wanted, name);
+          if (relative !== void 0 && relative.length === 0) break;
+          const read = yield* include(child, name, relative);
+          routers.push(yield* entry(name, read.meta, read.error));
+        }
+      }
+    }
+  });
+  if (root?.kind === "router") yield* visit(root, "");
+  else if (root?.kind === "dynamic" && options.scheduled !== true) {
+    const read = yield* include(root, "", wanted === void 0 ? void 0 : [...wanted]);
+    if (wanted === void 0 && read.meta !== void 0)
+      routers.push(yield* entry("", read.meta));
+  }
+  return { tools, routers };
+});
+var routerSkills = (root) => Effect_exports.gen(function* () {
+  const nodes = [];
+  const collect = (node, path) => {
+    nodes.push({ path, node });
+    if (node.kind === "router") {
+      for (const [key, child] of Object.entries(node.children))
+        if (child.kind === "router" || child.kind === "dynamic")
+          collect(child, joinPath(path, key));
+    }
+  };
+  if (root !== void 0) collect(root, "");
+  const skills = yield* Effect_exports.forEach(
+    nodes,
+    ({ path, node }) => (
+      // Skills that fail are skipped, so their failures are never reported.
+      routerMeta(node, []).pipe(
+        Effect_exports.flatMap((meta) => routerSkill(path, meta)),
+        Effect_exports.orElseSucceed(() => void 0)
+      )
+    ),
+    { concurrency: "unbounded" }
+  );
+  const names = /* @__PURE__ */ new Set();
+  return skills.filter((skill) => {
+    if (skill === void 0 || names.has(skill.name)) return false;
+    names.add(skill.name);
+    return true;
+  });
+});
+var routerSkill = (path, meta) => Effect_exports.gen(function* () {
+  if (meta?.instructions === void 0) return void 0;
+  const name = routerSkillName(path);
+  const description = ([meta.description, meta.title].find((text) => text !== void 0 && text.trim() !== "") ?? (path === "" ? "How to use this app's tools" : `How to use the ${path} tools`)).slice(0, skillFormatLimits.descriptionCharacters);
+  const content = `---
+name: ${name}
+description: ${JSON.stringify(description)}
+---
+
+${meta.instructions}
+`;
+  return yield* skillFromFiles([{ path: "SKILL.md", content }], { name });
+});
+
+export {
+  OpenapiErrorResponse,
+  OpenapiParameter,
+  OpenapiRequestBody,
+  OpenapiOperation,
+  isOpenapiReadMethod,
+  OpenapiToolsOptions,
+  OpenapiMediaType,
+  OpenapiError,
+  defaultOpenapiResponseLimits,
+  isOpenapiJsonSequence,
+  isOpenapiTextMedia,
+  isOpenapiFileSchema,
+  openapiBinaryResultSchema,
+  openapiMediaKind,
+  OpenapiCompileErrorCode,
+  OpenapiSkippedOperation,
+  OpenapiCompileError,
+  accountSecrets,
+  boundFailureMessage,
+  leavingProviderError,
+  parseMcpError,
+  parseSkillLoadFailed,
+  describeFailure,
+  failureDetail,
+  operationDescription,
+  fixedRouter,
+  readCatalog,
+  routerSkills
+};