stitchkit 0.100.2 → 0.101.0

package/dist/{index-k30h66yd.js → index-ck71tbcf.js}

@@ -1,17 +1,17 @@
 import {
   resolveRouteParamsSchema
-} from "./index-4gcnakhx.js";
+} from "./index-m38ej7e5.js";
 import {
   isUnsafeKey
-} from "./index-kzfs85xp.js";
+} from "./index-zsarb5xp.js";
 import {
   isRecord
-} from "./index-hffjpmq9.js";
+} from "./index-9jfdm5tg.js";
 
 // src/contract/tool-view.ts
 import { z } from "zod";
 var DECLARED_TOOL_VIEW = Symbol.for("stitchkit.toolView");
-function withToolView(endpoint, view) {
+function withToolView2(endpoint, view) {
   const declared = { ...view, [DECLARED_TOOL_VIEW]: true };
   return { ...endpoint, tool: { ...endpoint.tool, view: declared } };
 }
@@ -254,9 +254,9 @@ function assertResponseMetaEndpoint(prefix, key, ep) {
 }
 
 // src/contract/define.ts
-var ALL_TRANSPORTS = ["HTTP", "MCP", "AGENT", "CLI"];
-var TOOL_TRANSPORTS = ["MCP", "AGENT", "CLI"];
-function defineContract(meta, endpoints) {
+var ALL_TRANSPORTS2 = ["HTTP", "MCP", "AGENT", "CLI"];
+var TOOL_TRANSPORTS2 = ["MCP", "AGENT", "CLI"];
+function defineContract2(meta, endpoints) {
   const materializedEndpoints = {};
   for (const [key, endpoint] of Object.entries(endpoints)) {
     const params = resolveRouteParamsSchema(endpoint.path, endpoint.params);
@@ -293,7 +293,7 @@ function defineContract(meta, endpoints) {
     }
     const transports = new Set(ep.expose ? ep.expose.filter((t) => t !== "HTTP") : ["MCP", "AGENT"]);
     if (transports.size === 0) {
-      throw new Error(`Contract "${meta.prefix}": endpoint "${key}" sets tool options but is not exposed on any tool transport (${TOOL_TRANSPORTS.join(" / ")}) — a contract factory with toolExposure 'explicit' makes an omitted expose HTTP-only`);
+      throw new Error(`Contract "${meta.prefix}": endpoint "${key}" sets tool options but is not exposed on any tool transport (${TOOL_TRANSPORTS2.join(" / ")}) — a contract factory with toolExposure 'explicit' makes an omitted expose HTTP-only`);
     }
     if (tool.view !== undefined)
       assertToolView(meta.prefix, key, ep);
@@ -314,4 +314,4 @@ function defineContract(meta, endpoints) {
   return { meta, endpoints: materializedEndpoints };
 }
 
-export { withToolView, ALL_TRANSPORTS, TOOL_TRANSPORTS, defineContract };
+export { withToolView2, ALL_TRANSPORTS2, TOOL_TRANSPORTS2, defineContract2 };

package/dist/{index-eqqvgdb3.js → index-ct75c3at.js}

@@ -22,8 +22,8 @@ function jsonSchemaFields(jsonSchema) {
         continue;
       for (const field of jsonSchemaFields(member)) {
         const existing = byName.get(field.name);
-        const required2 = existing ? conjunctive ? existing.required || field.required : existing.required && field.required : field.required;
-        byName.set(field.name, existing ? { ...field, required: required2 } : field);
+        const required = existing ? conjunctive ? existing.required || field.required : existing.required && field.required : field.required;
+        byName.set(field.name, existing ? { ...field, required } : field);
       }
     }
     return [...byName.values()];

package/dist/{index-gw8bmyaj.js → index-djjhhgjk.js}

@@ -1,38 +1,38 @@
+import {
+  forbidden2,
+  conflict2
+} from "./index-n53mswt3.js";
+import {
+  probeAgentProcessSandbox2,
+  missingSandboxRestrictions2,
+  codingRefusal,
+  codingPathRefusal,
+  refuseMissingCodingPath
+} from "./index-ahvsksw5.js";
 import {
   NumericFileHandle,
-  assertContainedFileCurrent,
-  assertContainedParentCurrent,
-  containedEntryMetadata,
   descriptorPath,
   listContainedDirectory,
   missingContainedDirectories,
-  openContainedFile,
   openContainedParent,
+  openContainedFile,
+  assertContainedFileCurrent,
+  assertContainedParentCurrent,
+  containedEntryMetadata,
   openContainedParentFile,
   readContainedUtf8Handle,
   scanContainedFiles
-} from "./index-fhwqwxe0.js";
+} from "./index-ej331hah.js";
 import {
   loadDarwinBinding
-} from "./index-zjjyynm3.js";
-import {
-  codingPathRefusal,
-  codingRefusal,
-  missingSandboxRestrictions,
-  probeAgentProcessSandbox,
-  refuseMissingCodingPath
-} from "./index-qmy6zq75.js";
-import {
-  defineRuntimeTool
-} from "./index-d8m8zpd8.js";
+} from "./index-d4pa2bgs.js";
 import {
-  conflict,
-  forbidden
-} from "./index-2vtcmrj9.js";
+  defineRuntimeTool2
+} from "./index-jzczzcsb.js";
 
 // src/agent-runtime/coding-tool-contract.ts
 import { z } from "zod";
-var AgentCodingToolLimitsSchema = z.object({
+var AgentCodingToolLimitsSchema2 = z.object({
   maxPathBytes: z.int().positive(),
   maxReadBytes: z.int().positive(),
   maxWriteBytes: z.int().positive(),
@@ -47,7 +47,7 @@ var AgentCodingToolLimitsSchema = z.object({
   shellTimeoutMs: z.int().positive(),
   shellTerminationGraceMs: z.int().positive()
 }).strict();
-var AgentCodingToolAuthorizationSchema = z.discriminatedUnion("operation", [
+var AgentCodingToolAuthorizationSchema2 = z.discriminatedUnion("operation", [
   z.object({ operation: z.literal("read"), path: z.string().min(1) }).strict(),
   z.object({
     operation: z.literal("write"),
@@ -95,7 +95,7 @@ var AgentCodingToolAuthorizationSchema = z.discriminatedUnion("operation", [
     cwd: z.string().min(1)
   }).strict()
 ]);
-var AgentCodingToolPathAuthorizationSchema = z.object({ path: z.string().min(1) }).strict();
+var AgentCodingToolPathAuthorizationSchema2 = z.object({ path: z.string().min(1) }).strict();
 var CodingDeniedEntrySchema = z.object({
   path: z.string().min(1),
   kind: z.enum(["file", "directory", "symlink", "other"])
@@ -170,7 +170,7 @@ var DEFAULT_LIMITS = {
   shellTerminationGraceMs: 250
 };
 function resolveCodingToolLimits(input) {
-  return AgentCodingToolLimitsSchema.parse({ ...DEFAULT_LIMITS, ...input });
+  return AgentCodingToolLimitsSchema2.parse({ ...DEFAULT_LIMITS, ...input });
 }
 
 // src/agent-runtime/coding-tools.ts
@@ -238,14 +238,14 @@ async function existingCodingPath(root, requested, maxPathBytes) {
   return { absolute: resolved, relative: path.relative(root, resolved) || "." };
 }
 async function authorizeCodingTool(config, request) {
-  const parsed = AgentCodingToolAuthorizationSchema.parse(request);
+  const parsed = AgentCodingToolAuthorizationSchema2.parse(request);
   if (!await config.authorize(parsed))
-    forbidden("Coding tool permission denied");
+    forbidden2("Coding tool permission denied");
 }
 async function isCodingPathAuthorized(config, path2) {
   if (!config.authorizePath)
     return true;
-  const parsed = AgentCodingToolPathAuthorizationSchema.parse({ path: path2 });
+  const parsed = AgentCodingToolPathAuthorizationSchema2.parse({ path: path2 });
   return await config.authorizePath(parsed);
 }
 async function authorizeCodingPath(config, path2) {
@@ -427,7 +427,7 @@ async function digestFile(handle, size) {
   return hash.digest("hex");
 }
 function createFileCodingTools(config, limits) {
-  const read = defineRuntimeTool({
+  const read = defineRuntimeTool2({
     name: "read_file",
     description: "Read a bounded UTF-8 slice from a host-authorized workspace file.",
     identity: { serviceName: "coding", action: "read-file", method: "POST" },
@@ -491,7 +491,7 @@ function createFileCodingTools(config, limits) {
       };
     }
   });
-  const write = defineRuntimeTool({
+  const write = defineRuntimeTool2({
     name: "write_file",
     description: "Write bounded UTF-8 content to a host-authorized workspace file.",
     identity: { serviceName: "coding", action: "write-file", method: "POST" },
@@ -630,7 +630,7 @@ function compileWorkspaceGlob(pattern) {
 }
 function createListingCodingTools(config, limits) {
   const excluded = new Set(config.search?.excludeDirectories ?? DEFAULT_EXCLUDED_DIRECTORIES);
-  const list = defineRuntimeTool({
+  const list = defineRuntimeTool2({
     name: "list_directory",
     description: "List the direct entries of one workspace directory.",
     identity: { serviceName: "coding", action: "list-directory", method: "POST" },
@@ -672,7 +672,7 @@ function createListingCodingTools(config, limits) {
       };
     }
   });
-  const glob = defineRuntimeTool({
+  const glob = defineRuntimeTool2({
     name: "glob",
     description: "List workspace files matching a `**`/`*`/`?` pattern.",
     identity: { serviceName: "coding", action: "glob", method: "POST" },
@@ -894,7 +894,7 @@ async function editFile(config, limits, input) {
       const source = read.text;
       const baseSha256 = sha256(source);
       if (input.expectedSha256 !== undefined && baseSha256 !== input.expectedSha256) {
-        conflict("The file changed since it was read", {
+        conflict2("The file changed since it was read", {
           message: "The file changed since it was read",
           path: relative,
           expectedSha256: input.expectedSha256,
@@ -956,7 +956,7 @@ async function editFile(config, limits, input) {
   }
 }
 function createSearchAndPatchCodingTools(config, limits) {
-  const search = defineRuntimeTool({
+  const search = defineRuntimeTool2({
     name: "search_files",
     description: "Search bounded relative paths or UTF-8 file content under the workspace root.",
     identity: { serviceName: "coding", action: "search", method: "POST" },
@@ -965,7 +965,7 @@ function createSearchAndPatchCodingTools(config, limits) {
     transports: ["AGENT"],
     handler: ({ input }) => searchFiles(config, limits, input)
   });
-  const edit = defineRuntimeTool({
+  const edit = defineRuntimeTool2({
     name: "edit_file",
     description: "Replace an exact snippet in one workspace file.",
     identity: { serviceName: "coding", action: "edit-file", method: "POST" },
@@ -1165,7 +1165,7 @@ async function runCodingShell(input) {
 function createShellCodingTool(config, limits) {
   const executables = config.executables ?? {};
   const executableNames = Object.keys(executables).sort();
-  return defineRuntimeTool({
+  return defineRuntimeTool2({
     name: "run_command",
     description: "Run a finite host-declared executable with bounded arguments, time and output.",
     identity: { serviceName: "coding", action: "shell", method: "POST" },
@@ -1199,13 +1199,13 @@ function createShellCodingTool(config, limits) {
       let executableArgs = input.args;
       let environment = config.environment ?? {};
       if (config.sandbox) {
-        const grade = await probeAgentProcessSandbox(config.sandbox.adapter);
+        const grade = await probeAgentProcessSandbox2(config.sandbox.adapter);
         if (grade.grade === "unavailable") {
           codingRefusal("SANDBOX_UNAVAILABLE", "The configured process sandbox is unavailable", {
             details: { reason: grade.reason }
           });
         }
-        const missing = missingSandboxRestrictions(grade, config.sandbox.required);
+        const missing = missingSandboxRestrictions2(grade, config.sandbox.required);
         if (missing.length > 0) {
           codingRefusal("SANDBOX_INSUFFICIENT", "The process sandbox lacks required restrictions", {
             details: { missing, grade: grade.grade }
@@ -1223,7 +1223,7 @@ function createShellCodingTool(config, limits) {
           executableArgs = [...prepared.args];
           environment = prepared.environment ?? environment;
         } catch (error) {
-          const refreshed = await probeAgentProcessSandbox(config.sandbox.adapter, {
+          const refreshed = await probeAgentProcessSandbox2(config.sandbox.adapter, {
             refresh: true
           });
           codingRefusal("SANDBOX_UNAVAILABLE", "The process sandbox failed while preparing a command", {
@@ -1277,7 +1277,7 @@ var AGENT_CODING_TOOL_NAMES = {
   searchFiles: "search_files",
   writeFile: "write_file"
 };
-function createAgentCodingTools(config) {
+function createAgentCodingTools2(config) {
   if (!path5.isAbsolute(config.root))
     throw new Error("Coding tool root must be absolute");
   for (const executable of Object.values(config.executables ?? {})) {
@@ -1289,7 +1289,7 @@ function createAgentCodingTools(config) {
   const artifactTools = [];
   if (config.artifacts) {
     const artifacts = config.artifacts;
-    artifactTools.push(defineRuntimeTool({
+    artifactTools.push(defineRuntimeTool2({
       name: AGENT_CODING_TOOL_NAMES.readOutput,
       description: "Read a bounded byte slice from one opaque coding output artifact.",
       identity: { serviceName: "coding", action: "read-artifact", method: "POST" },
@@ -1338,7 +1338,7 @@ function createAgentCodingTools(config) {
     }));
     if (artifacts.search) {
       const search = artifacts.search;
-      artifactTools.push(defineRuntimeTool({
+      artifactTools.push(defineRuntimeTool2({
         name: AGENT_CODING_TOOL_NAMES.searchOutput,
         description: "Search a durable spilled output without loading it into context.",
         identity: { serviceName: "coding", action: "search-artifact", method: "POST" },
@@ -1386,4 +1386,4 @@ function createAgentCodingTools(config) {
   ];
 }
 
-export { AgentCodingToolLimitsSchema, AgentCodingToolAuthorizationSchema, AgentCodingToolPathAuthorizationSchema, createAgentCodingTools };
+export { AgentCodingToolLimitsSchema2, AgentCodingToolAuthorizationSchema2, AgentCodingToolPathAuthorizationSchema2, createAgentCodingTools2 };

package/dist/{index-8qt2m66q.js → index-dvwj1f43.js}

@@ -1,34 +1,34 @@
 import {
-  getRequestContext,
-  runWithRequestContext
-} from "./index-zfrhfn82.js";
+  AppError2,
+  STITCH_ERROR_STATUS2,
+  isRetryableStatus2,
+  isStitchErrorCode2
+} from "./index-n53mswt3.js";
 import {
-  coerceJsonArgs
-} from "./index-1zbbzgfh.js";
+  normalizeError2,
+  validateDeclaredOutput
+} from "./index-b2bz0kdm.js";
 import {
-  applyToolViewDefaults,
-  objectShapeKeys,
-  projectToolView
-} from "./index-0r0fbk7z.js";
+  coerceJsonArgs2
+} from "./index-9pw0a51a.js";
 import {
-  normalizeError,
-  validateDeclaredOutput
-} from "./index-znfs20ss.js";
+  applyToolViewDefaults,
+  projectToolView,
+  objectShapeKeys
+} from "./index-7z9ym7t8.js";
 import {
-  formatZodError
-} from "./index-p5r7qpdd.js";
+  runWithRequestContext2,
+  getRequestContext2
+} from "./index-r1z0rd9c.js";
 import {
-  AppError,
-  STITCH_ERROR_STATUS,
-  isRetryableStatus,
-  isStitchErrorCode
-} from "./index-2vtcmrj9.js";
+  formatZodError2
+} from "./index-1eeqpadm.js";
 import {
   isUnsafeKey
-} from "./index-kzfs85xp.js";
+} from "./index-zsarb5xp.js";
 import {
   isRecord
-} from "./index-hffjpmq9.js";
+} from "./index-9jfdm5tg.js";
 
 // src/tools/execute-args.ts
 function parseToolCallArguments(method, callArgs, {
@@ -47,8 +47,8 @@ function parseToolCallArguments(method, callArgs, {
       inputArgs[key] = value;
   }
   if (coerceJson) {
-    paramArgs = coerceJsonArgs(paramArgs, method.paramsSchema);
-    inputArgs = coerceJsonArgs(inputArgs, method.inputSchema);
+    paramArgs = coerceJsonArgs2(paramArgs, method.paramsSchema);
+    inputArgs = coerceJsonArgs2(inputArgs, method.inputSchema);
   }
   if (toolSurface)
     inputArgs = applyToolViewDefaults(inputArgs, method.toolView?.defaults);
@@ -61,7 +61,7 @@ function parseToolCallArguments(method, callArgs, {
       return { ok: false, message: "Invalid params", thrown: err };
     }
     if (!result.success) {
-      return { ok: false, message: `Invalid params: ${formatZodError(result.error)}` };
+      return { ok: false, message: `Invalid params: ${formatZodError2(result.error)}` };
     }
     params = result.data;
   }
@@ -74,7 +74,7 @@ function parseToolCallArguments(method, callArgs, {
       return { ok: false, message: "Invalid input", thrown: err };
     }
     if (!result.success) {
-      return { ok: false, message: `Invalid input: ${formatZodError(result.error)}` };
+      return { ok: false, message: `Invalid input: ${formatZodError2(result.error)}` };
     }
     input = result.data;
   }
@@ -84,13 +84,13 @@ function parseToolCallArguments(method, callArgs, {
 // src/tools/execute-result.ts
 var normalizedToolErrors = new WeakMap;
 function toolResultFromError(err) {
-  const appErr = normalizeError(err);
+  const appErr = normalizeError2(err);
   const result = {
     ok: false,
     code: appErr.code,
     details: appErr.details ?? { message: appErr.message },
     ...appErr.hint && { hint: appErr.hint },
-    retryable: appErr.retryable ?? isRetryableStatus(appErr.status)
+    retryable: appErr.retryable ?? isRetryableStatus2(appErr.status)
   };
   normalizedToolErrors.set(result, { normalized: appErr, cause: err });
   return result;
@@ -101,15 +101,15 @@ function toolErrorFromResult(result) {
     return retained.normalized;
   const details = isRecord(result.details) ? result.details : undefined;
   const message = typeof details?.message === "string" ? details.message : result.code;
-  const status = isStitchErrorCode(result.code) ? STITCH_ERROR_STATUS[result.code] : 500;
-  return new AppError(result.code, message, status, details, result.hint, undefined, result.retryable);
+  const status = isStitchErrorCode2(result.code) ? STITCH_ERROR_STATUS2[result.code] : 500;
+  return new AppError2(result.code, message, status, details, result.hint, undefined, result.retryable);
 }
 function toolCauseFromResult(result) {
   return normalizedToolErrors.get(result)?.cause;
 }
 
 // src/tools/execute.ts
-class ToolExecutionControlError extends Error {
+class ToolExecutionControlError2 extends Error {
   reason;
   constructor(reason) {
     super(`Agent tool execution stopped: ${reason}`);
@@ -123,8 +123,8 @@ function isPlainObject(value) {
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || proto === null;
 }
-function isToolExecutionControlError(value) {
-  return value instanceof ToolExecutionControlError;
+function isToolExecutionControlError2(value) {
+  return value instanceof ToolExecutionControlError2;
 }
 var noProgress = async () => {
   return;
@@ -134,10 +134,10 @@ async function executeToolMethod(method, call, options = {}) {
   return inToolCallContext({ source: context.source, toolName, method }, () => runToolMethod(method, call, options));
 }
 function inToolCallContext(call, body) {
-  const parent = getRequestContext();
+  const parent = getRequestContext2();
   if (!parent)
     return body();
-  return runWithRequestContext({
+  return runWithRequestContext2({
     ...parent,
     trace: parent.trace,
     dimensions: parent.dimensions ? { ...parent.dimensions } : undefined,
@@ -205,7 +205,7 @@ async function resolveToolExtension(extension, keys, rawArgs, context) {
     return { thrown: err };
   }
   if (!parsed.success)
-    return { invalid: formatZodError(parsed.error) };
+    return { invalid: formatZodError2(parsed.error) };
   try {
     const resolved = await extension.resolve({ ...rawArgs, ...parsed.data });
     return {
@@ -279,9 +279,9 @@ async function runToolMethod(method, { toolName, rawArgs, context }, {
     return { kind: "args" };
   };
   const finishThrown = async (err) => {
-    const before2 = await runBefore();
-    if (before2?.kind === "failure")
-      return before2.result;
+    const before = await runBefore();
+    if (before?.kind === "failure")
+      return before.result;
     await observed("onToolError", () => hooks?.onToolError?.({ toolName, error: err, context: hookContext, endpoint: method }));
     return finish(toolResultFromError(err), err);
   };
@@ -294,9 +294,9 @@ async function runToolMethod(method, { toolName, rawArgs, context }, {
     if ("thrown" in resolved)
       return finishThrown(resolved.thrown);
     if ("invalid" in resolved) {
-      const before2 = await runBefore();
-      if (before2?.kind === "failure")
-        return before2.result;
+      const before = await runBefore();
+      if (before?.kind === "failure")
+        return before.result;
       return finish({
         ok: false,
         code: "VALIDATION_ERROR",
@@ -334,10 +334,10 @@ async function runToolMethod(method, { toolName, rawArgs, context }, {
       toolSurface
     }));
   } catch (err) {
-    if (isToolExecutionControlError(err))
+    if (isToolExecutionControlError2(err))
       throw err;
     return finishThrown(err);
   }
 }
 
-export { parseToolCallArguments, toolResultFromError, toolErrorFromResult, toolCauseFromResult, ToolExecutionControlError, isToolExecutionControlError, executeToolMethod };
+export { parseToolCallArguments, toolResultFromError, toolErrorFromResult, toolCauseFromResult, ToolExecutionControlError2, isToolExecutionControlError2, executeToolMethod };

package/dist/index-e05cjgtf.js

@@ -0,0 +1,144 @@
+import {
+  isRecord
+} from "./index-9jfdm5tg.js";
+
+// src/telegram/send-failure.ts
+var BY_DESCRIPTION = [
+  [/bot was blocked by the user|bot was kicked/i, "blocked-by-user"],
+  [/user is deactivated|account is deactivated/i, "user-deactivated"],
+  [/can'?t initiate conversation|need to start a conversation/i, "not-started"],
+  [/chat not found|peer_id_invalid|user not found/i, "chat-not-found"],
+  [/too many requests|retry later|flood/i, "rate-limited"],
+  [
+    /message is too long|can'?t parse entities|message text is empty|wrong file identifier|button_url_invalid/i,
+    "message-invalid"
+  ]
+];
+var TRAITS = {
+  "blocked-by-user": { retryable: false, recipientUnreachable: true },
+  "user-deactivated": { retryable: false, recipientUnreachable: true },
+  "chat-not-found": { retryable: false, recipientUnreachable: true },
+  "not-started": { retryable: false, recipientUnreachable: true },
+  "rate-limited": { retryable: true, recipientUnreachable: false },
+  "message-invalid": { retryable: false, recipientUnreachable: false },
+  "server-error": { retryable: true, recipientUnreachable: false },
+  unknown: { retryable: false, recipientUnreachable: false }
+};
+function isSendFailureReason(value) {
+  return Object.hasOwn(TRAITS, value);
+}
+var TELEGRAM_SEND_FAILURE_REASONS2 = Object.keys(TRAITS).filter(isSendFailureReason);
+function numberAt(value, keys) {
+  if (!isRecord(value))
+    return;
+  for (const key of keys) {
+    const candidate = value[key];
+    if (typeof candidate === "number" && Number.isFinite(candidate))
+      return candidate;
+  }
+  return;
+}
+function statusOf(value, depth = 0) {
+  if (!isRecord(value) || depth > 4)
+    return;
+  const direct = numberAt(value, ["error_code", "statusCode", "status"]);
+  if (direct !== undefined && direct >= 400 && direct < 600)
+    return direct;
+  const nested = value.cause ?? value.response ?? value.error;
+  return nested === value ? undefined : statusOf(nested, depth + 1);
+}
+function retryAfterOf(value, depth = 0) {
+  if (!isRecord(value) || depth > 4)
+    return;
+  const direct = numberAt(value.parameters, ["retry_after"]);
+  if (direct !== undefined)
+    return direct;
+  const nested = value.cause ?? value.response ?? value.error;
+  return nested === value ? undefined : retryAfterOf(nested, depth + 1);
+}
+function descriptionOf(value, depth = 0) {
+  if (typeof value === "string")
+    return value;
+  if (value instanceof Error) {
+    const nested = isRecord(value) ? descriptionOf(value.cause, depth + 1) : "";
+    return `${value.message} ${nested}`.trim();
+  }
+  if (!isRecord(value) || depth > 4)
+    return "";
+  const own = typeof value.description === "string" ? value.description : "";
+  const message = typeof value.message === "string" ? value.message : "";
+  const nested = descriptionOf(value.cause ?? value.response ?? value.error, depth + 1);
+  return [own, message, nested].filter(Boolean).join(" ");
+}
+function classifyTelegramSendFailure2(error) {
+  const status = statusOf(error);
+  const retryAfterSeconds = retryAfterOf(error);
+  const description = descriptionOf(error);
+  if (retryAfterSeconds !== undefined) {
+    return {
+      reason: "rate-limited",
+      ...status !== undefined && { status },
+      retryAfterSeconds,
+      retryable: true,
+      recipientUnreachable: false,
+      evidence: "parameters"
+    };
+  }
+  for (const [pattern, reason] of BY_DESCRIPTION) {
+    if (pattern.test(description)) {
+      return {
+        reason,
+        ...status !== undefined && { status },
+        ...TRAITS[reason],
+        evidence: "description"
+      };
+    }
+  }
+  if (status === 429) {
+    return {
+      reason: "rate-limited",
+      status,
+      retryable: true,
+      recipientUnreachable: false,
+      evidence: "status"
+    };
+  }
+  if (status !== undefined && status >= 500) {
+    return {
+      reason: "server-error",
+      status,
+      retryable: true,
+      recipientUnreachable: false,
+      evidence: "status"
+    };
+  }
+  return {
+    reason: "unknown",
+    ...status !== undefined && { status },
+    retryable: false,
+    recipientUnreachable: false,
+    evidence: "none"
+  };
+}
+var EDIT_REFUSALS = [
+  [/message is not modified/i, "not-modified"],
+  [
+    /message to (edit|delete) not found|message_id_invalid|message identifier is not specified/i,
+    "message-gone"
+  ],
+  [
+    /message can'?t be (edited|deleted)|there is no (text|caption) in the message to edit/i,
+    "message-locked"
+  ],
+  [/query is too old|query id is invalid/i, "query-expired"]
+];
+function classifyTelegramEditRefusal(error) {
+  const description = descriptionOf(error);
+  for (const [pattern, refusal] of EDIT_REFUSALS) {
+    if (pattern.test(description))
+      return refusal;
+  }
+  return "other";
+}
+
+export { TELEGRAM_SEND_FAILURE_REASONS2, classifyTelegramSendFailure2, classifyTelegramEditRefusal };