stitchkit 0.70.5 → 0.71.0

package/dist/telegram.js

@@ -0,0 +1,224 @@
+import {
+  isRecord
+} from "./index-qyrqwr4c.js";
+
+// src/telegram/init-data.ts
+import { z } from "zod";
+var TelegramInitDataUserSchema = z.object({
+  id: z.int(),
+  is_bot: z.boolean().optional(),
+  first_name: z.string(),
+  last_name: z.string().optional(),
+  username: z.string().optional(),
+  language_code: z.string().optional(),
+  is_premium: z.boolean().optional(),
+  allows_write_to_pm: z.boolean().optional(),
+  photo_url: z.string().optional()
+}).transform((user) => ({
+  id: user.id,
+  firstName: user.first_name,
+  ...user.is_bot !== undefined && { isBot: user.is_bot },
+  ...user.last_name !== undefined && { lastName: user.last_name },
+  ...user.username !== undefined && { username: user.username },
+  ...user.language_code !== undefined && { languageCode: user.language_code },
+  ...user.is_premium !== undefined && { isPremium: user.is_premium },
+  ...user.allows_write_to_pm !== undefined && { allowsWriteToPm: user.allows_write_to_pm },
+  ...user.photo_url !== undefined && { photoUrl: user.photo_url }
+}));
+var encoder = new TextEncoder;
+async function hmacSha256(key, message) {
+  const imported = await crypto.subtle.importKey("raw", key, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  return crypto.subtle.sign("HMAC", imported, encoder.encode(message));
+}
+function toHex(buffer) {
+  return Array.from(new Uint8Array(buffer), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function digestsEqual(a, b) {
+  if (a.length !== b.length)
+    return false;
+  let difference = 0;
+  for (let index = 0;index < a.length; index += 1) {
+    difference |= a.charCodeAt(index) ^ b.charCodeAt(index);
+  }
+  return difference === 0;
+}
+function optionalUser(raw, key) {
+  const encoded = raw[key];
+  if (encoded === undefined)
+    return;
+  return TelegramInitDataUserSchema.parse(JSON.parse(encoded));
+}
+async function verifyTelegramInitData(options) {
+  if (!options.botToken)
+    throw new TypeError("botToken is required to verify initData");
+  if (options.maxAgeSeconds !== undefined && (!Number.isFinite(options.maxAgeSeconds) || options.maxAgeSeconds < 0)) {
+    throw new TypeError("maxAgeSeconds must be a non-negative finite number");
+  }
+  const params = new URLSearchParams(options.initData);
+  const hash = params.get("hash");
+  if (!hash)
+    return { valid: false, reason: "missing-hash" };
+  const signed = {};
+  for (const [key, value] of params) {
+    if (key === "hash")
+      continue;
+    signed[key] = value;
+  }
+  const dataCheckString = Object.keys(signed).sort().map((key) => `${key}=${signed[key]}`).join(`
+`);
+  const secretKey = await hmacSha256(encoder.encode("WebAppData"), options.botToken);
+  const expected = toHex(await hmacSha256(secretKey, dataCheckString));
+  if (!digestsEqual(expected, hash.toLowerCase())) {
+    return { valid: false, reason: "signature-mismatch" };
+  }
+  const authDateSeconds = Number(signed.auth_date);
+  if (!Number.isSafeInteger(authDateSeconds) || authDateSeconds <= 0) {
+    return { valid: false, reason: "malformed" };
+  }
+  const nowMs = options.now?.() ?? Date.now();
+  const ageSeconds = Math.floor(nowMs / 1000) - authDateSeconds;
+  if (options.maxAgeSeconds !== undefined && ageSeconds > options.maxAgeSeconds) {
+    return { valid: false, reason: "expired", ageSeconds };
+  }
+  let user;
+  let receiver;
+  try {
+    user = optionalUser(signed, "user");
+    receiver = optionalUser(signed, "receiver");
+  } catch {
+    return { valid: false, reason: "malformed" };
+  }
+  return {
+    valid: true,
+    data: {
+      ...user !== undefined && { user },
+      ...receiver !== undefined && { receiver },
+      authDate: new Date(authDateSeconds * 1000),
+      ageSeconds,
+      ...signed.query_id !== undefined && { queryId: signed.query_id },
+      ...signed.start_param !== undefined && { startParam: signed.start_param },
+      ...signed.chat_type !== undefined && { chatType: signed.chat_type },
+      ...signed.chat_instance !== undefined && { chatInstance: signed.chat_instance },
+      raw: Object.freeze({ ...signed })
+    }
+  };
+}
+// 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 RETRYABLE = new Set([
+  "rate-limited",
+  "server-error"
+]);
+var UNREACHABLE = new Set([
+  "blocked-by-user",
+  "user-deactivated",
+  "chat-not-found",
+  "not-started"
+]);
+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 nested2 = isRecord(value) ? descriptionOf(value.cause, depth + 1) : "";
+    return `${value.message} ${nested2}`.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 classifyTelegramSendFailure(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 },
+        retryable: RETRYABLE.has(reason),
+        recipientUnreachable: UNREACHABLE.has(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"
+  };
+}
+export {
+  verifyTelegramInitData,
+  classifyTelegramSendFailure
+};

package/dist/tool-invoker.js

@@ -1,9 +1,9 @@
 import {
   createToolInvoker
-} from "./index-ekkt4gy9.js";
-import"./index-ejv31h14.js";
-import"./index-qm87g51s.js";
-import"./index-w9m1wznn.js";
+} from "./index-jqtsc9mj.js";
+import"./index-7qy2ex0m.js";
+import"./index-s4c8wy8m.js";
+import"./index-nemjkxjp.js";
 import"./index-22by16v6.js";
 import"./index-cby4ar3v.js";
 import"./index-nt1mp8km.js";

package/dist/tools.js

@@ -4,7 +4,7 @@ import {
 import {
   buildToolManifest,
   mountAgent
-} from "./index-trrf7nch.js";
+} from "./index-ezmn6ac6.js";
 import"./index-3xnq72rz.js";
 import {
   signJwt,
@@ -20,7 +20,7 @@ import {
 } from "./index-vbf2p6me.js";
 import {
   createToolInvoker
-} from "./index-ekkt4gy9.js";
+} from "./index-jqtsc9mj.js";
 import {
   WaitTimeoutError,
   createCli,
@@ -29,10 +29,10 @@ import {
   fetchPinnedDocument,
   readCapped,
   runWaitOperation
-} from "./index-tnazr5tc.js";
+} from "./index-pz7ytdga.js";
 import {
   collectToolSurface
-} from "./index-hxtm2xr2.js";
+} from "./index-k2zczx1g.js";
 import {
   createRuntimeToolFactory,
   defineRuntimeTool
@@ -41,19 +41,19 @@ import {
   collectTools,
   createToolRunner,
   formatToolError
-} from "./index-ejv31h14.js";
+} from "./index-7qy2ex0m.js";
 import {
   ToolExecutionControlError,
   coerceJsonArgs,
   executeToolMethod,
   isToolExecutionControlError,
   toolResultFromError
-} from "./index-qm87g51s.js";
+} from "./index-s4c8wy8m.js";
 import {
   getRequestContext,
   getTraceId,
   runWithRequestContext
-} from "./index-w9m1wznn.js";
+} from "./index-nemjkxjp.js";
 import {
   ManagedFileError
 } from "./index-bfcpjw20.js";