apps 0.0.1-beta.7 → 0.0.1-beta.70

package/js/{chunk-FL2QR3XW.js → chunk-4NCIPADO.js}

@@ -1,13 +1,15 @@
 import {
   skillFromFiles
-} from "./chunk-IPI4MFSN.js";
+} from "./chunk-XBG7HHXC.js";
 import {
   joinPath,
   mergeMeta
-} from "./chunk-Z5M2LQOZ.js";
+} from "./chunk-ZEJ3IKEC.js";
 import {
-  parseProviderError
-} from "./chunk-MKWZPDR6.js";
+  isShortenedUpstream,
+  parseProviderError,
+  providerError
+} from "./chunk-ZR7QAG67.js";
 import {
   ApiErrorResponse,
   HostDeclarationInvalid,
@@ -15,37 +17,45 @@ import {
   HostedRouter,
   HostedTool,
   HostedToolSummary,
+  McpCredentialsUnverified,
   McpError,
-  maxFailureMessageLength
-} from "./chunk-WLE7WX2U.js";
+  McpError2,
+  SkillLoadFailed as SkillLoadFailed2
+} from "./chunk-JW5LYSER.js";
 import {
-  AppDatabaseError
-} from "./chunk-N7YDVXYJ.js";
+  CacheError,
+  FailureCode,
+  FailureFieldName,
+  FetchOptionUnsupported,
+  NetworkRefused,
+  cacheLimits,
+  maxFailureFieldLength,
+  maxFailureFields,
+  maxFailureMessageLength,
+  maxUpstreamMessageLength
+} from "./chunk-7LMU3ER3.js";
 import {
   SkillLoadFailed,
   skillFormatLimits
-} from "./chunk-JU7VHODU.js";
+} from "./chunk-H72MEDMN.js";
 import {
   jsonSchemaDocument
-} from "./chunk-5T57N25Q.js";
-import {
-  AppStorageError,
-  AppStorageUnavailable
-} from "./chunk-PZB6T6KU.js";
+} from "./chunk-KGCTYL2S.js";
 import {
   AccountId,
   HttpUrl,
   JsonObject
-} from "./chunk-27F7W2LG.js";
+} from "./chunk-H2CJWXA3.js";
 import {
   Cause_exports,
   Effect_exports,
+  Match_exports,
   Option_exports,
   Predicate_exports,
   Redacted_exports,
   Result_exports,
   Schema_exports
-} from "./chunk-CDL5PM2Q.js";
+} from "./chunk-IFJU5SYQ.js";
 
 // src/contracts/openapi.ts
 var OpenapiErrorResponse = Schema_exports.Struct({
@@ -59,7 +69,8 @@ var OpenapiErrorResponse = Schema_exports.Struct({
 });
 var OpenapiParameter = Schema_exports.Struct({
   name: Schema_exports.String,
-  in: Schema_exports.Literals(["path", "query", "header", "cookie"]),
+  /** 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),
@@ -84,7 +95,7 @@ var OpenapiOperation = Schema_exports.Struct({
   /** 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"]),
+  method: Schema_exports.Literals(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "QUERY"]),
   path: Schema_exports.String,
   baseUrl: HttpUrl,
   openapi: Schema_exports.String,
@@ -104,6 +115,7 @@ var OpenapiOperation = Schema_exports.Struct({
   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,
@@ -136,16 +148,30 @@ var OpenapiToolsOptions = Schema_exports.Struct({
     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)
+  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 isOpenapiTextMedia = (type) => /^(?:text\/|application\/(?:[\w.-]+\+)?(?:json|xml)|application\/(?:javascript|x-ndjson|x-www-form-urlencoded))/i.test(
+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";
@@ -158,23 +184,151 @@ var openapiBinaryResultSchema = {
   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";
+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: count2 }) => `${first.method} ${first.path}${count2 > 1 ? ` and ${count2 - 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);
+  }
+};
+var OpenapiToolName = Schema_exports.Struct({
+  /** The tool name relative to the router, as `withApprovals` receives it. */
+  name: Schema_exports.String,
+  /** The HTTP method, such as `GET`. */
+  method: Schema_exports.String,
+  /** The request path, including any `pathPrefix`. */
+  path: Schema_exports.String,
+  operationId: Schema_exports.optionalKey(Schema_exports.String),
+  /** After `kinds` (keyed by `operationId`, else `name`); otherwise reading methods are queries. */
+  kind: Schema_exports.Literals(["query", "mutation"]),
+  /** Callable without credentials, so every account and a router without one expose it. */
+  public: Schema_exports.Boolean,
+  /** The `methods` and `oauth` entries whose accounts expose it. */
+  methods: Schema_exports.Array(Schema_exports.String)
+});
+var OpenapiToolNames = Schema_exports.Struct({
+  tools: Schema_exports.Array(OpenapiToolName),
+  /**
+   * Operations the compiler left out, and why. An operation it imports but no configured `methods`
+   * or `oauth` entry can authorize is missing from `tools` and is not listed here.
+   */
+  skipped: Schema_exports.Array(OpenapiSkippedOperation)
+});
 
 // src/implementation/failure-detail.ts
-var storageMessages = {
-  schema: "The app's database schema is invalid.",
-  schema_changed: "The app's database schema changed during this operation. Retry it.",
-  table: "The operation used a table the app's database schema does not declare.",
-  index: "The operation used an index the table does not declare, or used it incorrectly.",
-  range: "The index range is invalid for the declared index.",
-  value: "A value does not match the table's declared field schema.",
-  readonly: "Queries cannot write. Move writes into a mutation.",
-  cursor: "The pagination cursor is invalid or belongs to a different query.",
-  limit: "The operation exceeded a per-invocation app data limit.",
-  closed: "The database session closed before this operation finished.",
-  storage: "App storage failed to complete the operation.",
-  replay: "A workflow step replayed with different input than its first run."
+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 was not available for this operation.",
+  storage: "The app cache failed to complete the operation.",
+  timeout: "The app cache did not respond in time."
+};
+var count = (value) => value.toLocaleString("en-US");
+var cacheLimitMessages = {
+  keyBytes: `A cache key exceeded the app cache's limit of ${count(cacheLimits.keyBytes)} bytes per key.`,
+  entryBytes: `A cache value exceeded the app cache's limit of ${count(cacheLimits.entryBytes)} bytes per entry.`,
+  batchBytes: `A cache read or write exceeded the app cache's limit of ${count(cacheLimits.batchBytes)} bytes per batch.`,
+  batchEntries: `A cache read or write exceeded the app cache's limit of ${count(cacheLimits.batchEntries)} entries per batch.`,
+  totalBytes: `The app cache is full: it holds at most ${count(cacheLimits.totalBytes)} bytes.`,
+  totalEntries: `The app cache is full: it holds at most ${count(cacheLimits.totalEntries)} entries.`
+};
+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") {
@@ -194,54 +348,155 @@ var accountFieldSecrets = (accounts) => {
   return [...found].sort((a, b) => b.length - a.length);
 };
 var accountSecrets = (accounts) => accountFieldSecrets(Redacted_exports.value(accounts));
-var boundFailureMessage = (message, secrets) => {
-  let redacted = message;
+var replaceSecrets = (text, secrets) => {
+  let redacted = text;
   for (const secret of secrets) redacted = redacted.split(secret).join("[redacted]");
-  return redacted.length <= maxFailureMessageLength ? redacted : `${redacted.slice(0, maxFailureMessageLength - 1)}\u2026`;
+  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 count2 = 0;
+  for (const [key, value] of Object.entries(error)) {
+    if (count2 === 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;
+    count2++;
+  }
+  return count2 === 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(AppDatabaseError)(error))
+  if (Schema_exports.is(CacheError)(error))
     return {
       source: "storage",
-      errorName: "AppDatabaseError",
+      errorName: "CacheError",
       code: error.reason,
-      message: boundFailureMessage(ownMessage(error) ?? storageMessages[error.reason], secrets)
+      message: error.limit === void 0 ? cacheMessages[error.reason] : cacheLimitMessages[error.limit]
     };
-  if (Schema_exports.is(AppStorageUnavailable)(error))
+  if (Schema_exports.is(OpenapiError)(error))
     return {
-      source: "storage",
-      errorName: "AppStorageUnavailable",
-      message: "App storage is not available on this host."
+      source: "service",
+      errorName: "OpenapiError",
+      code: error.reason,
+      message: boundFailureMessage(openapiFailureMessage(error), secrets)
     };
-  if (Schema_exports.is(AppStorageError)(error))
+  if (Schema_exports.is(McpError)(error))
     return {
-      source: "storage",
-      errorName: "AppStorageError",
-      message: "App storage failed to complete the operation."
+      source: "service",
+      errorName: "McpError",
+      code: error.reason,
+      message: mcpMessage(error)
     };
-  if (Schema_exports.is(OpenapiError)(error))
+  if (Schema_exports.is(McpCredentialsUnverified)(error))
     return {
       source: "service",
-      errorName: "OpenapiError",
-      code: error.reason,
-      message: error.reason === "request" ? error.status === void 0 ? "The API request failed before a response arrived." : `The API responded with HTTP ${error.status}, which its OpenAPI document does not declare as an error with a message.` : error.reason === "invalid_input" ? "The input could not be encoded as a request for this API operation." : "The API's OpenAPI definition for this operation is invalid."
+      errorName: "McpCredentialsUnverified",
+      code: error.anonymous === "answered" ? "anonymous_access" : error.anonymous.reason,
+      message: unverifiedMessage(error)
     };
-  if (error instanceof 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 {
@@ -254,21 +509,11 @@ var failureDetail = (error, secrets) => {
 // src/implementation/router-catalog.ts
 var safeFailure = (error, secrets) => {
   const provider = parseProviderError(error);
-  if (Option_exports.isSome(provider)) return provider.value;
-  const skills = Schema_exports.decodeUnknownOption(SkillLoadFailed)(error);
-  if (Option_exports.isSome(skills)) {
-    const { reason, message, status } = skills.value;
-    return new SkillLoadFailed({
-      reason,
-      ...message ? { message } : {},
-      ...status === void 0 ? {} : { status }
-    });
-  }
-  const mcp = Schema_exports.decodeUnknownOption(McpError)(error);
-  if (Option_exports.isSome(mcp)) {
-    const { phase, reason, status } = mcp.value;
-    return new McpError({ phase, reason, ...status === void 0 ? {} : { status } });
-  }
+  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));
 };
@@ -490,17 +735,29 @@ export {
   OpenapiParameter,
   OpenapiRequestBody,
   OpenapiOperation,
+  isOpenapiReadMethod,
   OpenapiToolsOptions,
+  OpenapiMediaType,
   OpenapiError,
   defaultOpenapiResponseLimits,
+  isOpenapiJsonSequence,
   isOpenapiTextMedia,
   isOpenapiFileSchema,
   openapiBinaryResultSchema,
   openapiMediaKind,
+  OpenapiCompileErrorCode,
+  OpenapiSkippedOperation,
+  OpenapiCompileError,
+  OpenapiToolName,
+  OpenapiToolNames,
   accountSecrets,
   boundFailureMessage,
+  leavingProviderError,
+  parseMcpError,
+  parseSkillLoadFailed,
   describeFailure,
   failureDetail,
+  operationDescription,
   fixedRouter,
   readCatalog,
   routerSkills

package/js/chunk-5FHWNLCI.js

@@ -0,0 +1,88 @@
+import {
+  Predicate_exports
+} from "./chunk-IFJU5SYQ.js";
+
+// ../utils/src/recorded-message.ts
+var RecordedMessage = /* @__PURE__ */ Symbol.for("@executor-js/utils/RecordedMessage");
+var recordedMessage = (error) => {
+  if (Predicate_exports.hasProperty(error, RecordedMessage)) {
+    const message = error[RecordedMessage];
+    return typeof message === "string" ? message : void 0;
+  }
+  return protocolErrorMessage(error) ?? sqlErrorMessage(error);
+};
+var jsonRpcMeanings = {
+  [-32700]: "Parse error",
+  [-32600]: "Invalid request",
+  [-32601]: "Method not found",
+  [-32602]: "Invalid params",
+  [-32603]: "Internal error",
+  [-32002]: "Resource not found"
+};
+var protocolErrorMessage = (error) => {
+  if (!Predicate_exports.isTagged(error, "ProtocolError") || !Predicate_exports.hasProperty(error, "code") || typeof error.code !== "number" || !Predicate_exports.hasProperty(error, "message") || !Predicate_exports.isString(error.message))
+    return void 0;
+  const code = error.code;
+  const refusal = /^Tool '.*' not found$/s.test(error.message) ? ": the requested tool does not exist" : error.message.startsWith("Invalid parameters for tool '") ? ": the tool's arguments failed validation" : "";
+  const meaning = jsonRpcMeanings[code];
+  const kind = meaning === void 0 ? "JSON-RPC error with an unlisted code" : `${meaning} (${code})`;
+  return kind + refusal;
+};
+var sqlReasons = /* @__PURE__ */ new Set([
+  "ConnectionError",
+  "AuthenticationError",
+  "AuthorizationError",
+  "SqlSyntaxError",
+  "UniqueViolation",
+  "ConstraintError",
+  "DeadlockError",
+  "SerializationError",
+  "LockTimeoutError",
+  "StatementTimeoutError",
+  "UnknownError"
+]);
+var sqlMessages = new Set(
+  [
+    "A pipelined query completed out of order",
+    "Connection closed",
+    "Connection closed during startup",
+    "Connection is closed",
+    "Connection timed out",
+    "Failed to connect",
+    "Failed to decode row",
+    "Failed to encode query",
+    "Failed to negotiate TLS",
+    "Failed to parse SSLRequest error response",
+    "Failed to parse server messages",
+    "Failed to parse server response",
+    "Failed to write query",
+    "Failed to write query batch",
+    "Invalid SSLRequest response",
+    "MD5 authentication failed",
+    "No password configured",
+    "Protocol desync",
+    "Query cancellation timed out",
+    "Query failed",
+    "SCRAM authentication failed",
+    "SCRAM exchange did not complete",
+    "SCRAM server verification failed",
+    "Server refused TLS",
+    "Socket error",
+    "Stream cancellation timed out",
+    "The server reported an error",
+    "Unsupported authentication method"
+  ].map((message) => `PgConnection: ${message}`)
+);
+var sqlErrorMessage = (error) => {
+  if (!Predicate_exports.isTagged(error, "SqlError") || !Predicate_exports.hasProperty(error, "reason"))
+    return void 0;
+  const reason = error.reason;
+  const kind = Predicate_exports.hasProperty(reason, "_tag") && Predicate_exports.isString(reason._tag) && sqlReasons.has(reason._tag) ? reason._tag : "an unlisted kind";
+  const message = Predicate_exports.hasProperty(reason, "message") && Predicate_exports.isString(reason.message) && sqlMessages.has(reason.message) ? `: ${reason.message}` : "";
+  return `The database failed (${kind})${message}`;
+};
+
+export {
+  RecordedMessage,
+  recordedMessage
+};