@inkeep/agents-core 0.58.14 → 0.58.15

package/dist/retry/retryable-errors.js

@@ -0,0 +1,72 @@
+//#region src/retry/retryable-errors.ts
+const TIER_1_ALWAYS_RETRY = new Set(["40001", "40P01"]);
+const TIER_2_CONNECTION = new Set([
+	"08000",
+	"08003",
+	"08006",
+	"08001",
+	"08004",
+	"57P01",
+	"57P03"
+]);
+const TIER_3_RESOURCE = new Set([
+	"53000",
+	"53100",
+	"53200",
+	"53300",
+	"55P03",
+	"57014"
+]);
+const DEFAULT_RETRYABLE_CODES = new Set([
+	...TIER_1_ALWAYS_RETRY,
+	...TIER_2_CONNECTION,
+	...TIER_3_RESOURCE
+]);
+const RETRYABLE_NODE_ERROR_CODES = new Set([
+	"ECONNREFUSED",
+	"ECONNRESET",
+	"EPIPE",
+	"ETIMEDOUT",
+	"EHOSTUNREACH",
+	"ENETUNREACH",
+	"EAI_AGAIN"
+]);
+const RETRYABLE_POOL_MESSAGES = [
+	"timeout exceeded when trying to connect",
+	"Connection terminated due to connection timeout",
+	"Connection terminated unexpectedly"
+];
+const NON_RETRYABLE_POOL_MESSAGES = ["Cannot use a pool after calling end on the pool"];
+const SQLSTATE_PATTERN = /^[0-9A-Z]{5}$/;
+function getPostgresErrorCode(error) {
+	if (!error || typeof error !== "object") return void 0;
+	const err = error;
+	if (err.cause?.code && typeof err.cause.code === "string" && SQLSTATE_PATTERN.test(err.cause.code)) return err.cause.code;
+	if (err.code && typeof err.code === "string" && SQLSTATE_PATTERN.test(err.code)) return err.code;
+}
+function isRetryableError(error, retryableCodes = DEFAULT_RETRYABLE_CODES) {
+	if (!error || typeof error !== "object") return false;
+	const err = error;
+	const sqlstate = getPostgresErrorCode(error);
+	if (sqlstate && retryableCodes.has(sqlstate)) return true;
+	const nodeCode = err.code ?? err.cause?.code;
+	if (typeof nodeCode === "string" && RETRYABLE_NODE_ERROR_CODES.has(nodeCode)) return true;
+	const messages = [err.message, err.cause?.message].filter((m) => typeof m === "string");
+	for (const message of messages) {
+		if (NON_RETRYABLE_POOL_MESSAGES.some((m) => message.includes(m))) return false;
+		if (RETRYABLE_POOL_MESSAGES.some((m) => message.includes(m))) return true;
+	}
+	return false;
+}
+function isForeignKeyViolation(error) {
+	return getPostgresErrorCode(error) === "23503";
+}
+function isSerializationError(error) {
+	if (!error || typeof error !== "object") return false;
+	const err = error;
+	const code = err?.cause?.code ?? err?.code;
+	return code === "40001" || code === "40P01" || code === "XX000";
+}
+
+//#endregion
+export { DEFAULT_RETRYABLE_CODES, RETRYABLE_NODE_ERROR_CODES, RETRYABLE_POOL_MESSAGES, getPostgresErrorCode, isForeignKeyViolation, isRetryableError, isSerializationError };

package/dist/retry/withRetry.d.ts

@@ -0,0 +1,15 @@
+//#region src/retry/withRetry.d.ts
+interface RetryOptions {
+  maxRetries?: number;
+  baseDelayMs?: number;
+  maxDelayMs?: number;
+  retryableCodes?: Set<string>;
+  context?: string;
+  noRetry?: boolean;
+}
+declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+declare function withRetryTransaction<T>(db: {
+  transaction: (fn: (tx: any) => Promise<T>) => Promise<T>;
+}, txFn: (tx: any) => Promise<T>, options?: Omit<RetryOptions, 'noRetry'>): Promise<T>;
+//#endregion
+export { RetryOptions, withRetry, withRetryTransaction };

package/dist/retry/withRetry.js

@@ -0,0 +1,37 @@
+import { getLogger } from "../utils/logger.js";
+import { DEFAULT_RETRYABLE_CODES, getPostgresErrorCode, isRetryableError } from "./retryable-errors.js";
+
+//#region src/retry/withRetry.ts
+const logger = getLogger("retry");
+async function withRetry(fn, options = {}) {
+	const { maxRetries = 3, baseDelayMs = 50, maxDelayMs = 5e3, retryableCodes = DEFAULT_RETRYABLE_CODES, context = "db-operation", noRetry = false } = options;
+	if (noRetry) return fn();
+	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
+		return await fn();
+	} catch (error) {
+		const isLastAttempt = attempt === maxRetries;
+		const retryable = isRetryableError(error, retryableCodes);
+		if (isLastAttempt || !retryable) throw error;
+		const expDelay = Math.min(maxDelayMs, baseDelayMs * 2 ** attempt);
+		const jitteredDelay = Math.random() * expDelay;
+		logger.warn({
+			context,
+			attempt: attempt + 1,
+			maxRetries,
+			delayMs: Math.round(jitteredDelay),
+			errorCode: getPostgresErrorCode(error) ?? error?.code ?? error?.cause?.code,
+			errorMessage: error?.message ?? String(error)
+		}, "Retrying transient database error");
+		await new Promise((resolve) => setTimeout(resolve, jitteredDelay));
+	}
+	throw new Error("unreachable");
+}
+async function withRetryTransaction(db, txFn, options = {}) {
+	return withRetry(() => db.transaction(txFn), {
+		...options,
+		context: options.context ?? "transaction"
+	});
+}
+
+//#endregion
+export { withRetry, withRetryTransaction };

package/dist/validation/dolt-schemas.d.ts

@@ -32,8 +32,8 @@ declare const BranchNameParamsSchema: z.ZodObject<{
 }, z.core.$strip>;
 declare const ResolvedRefSchema: z.ZodObject<{
   type: z.ZodEnum<{
-    tag: "tag";
     commit: "commit";
+    tag: "tag";
     branch: "branch";
   }>;
   name: z.ZodString;