@hiai-gg/docsmint 0.8.1 → 0.8.2

package/dist/backend/index.js

@@ -45791,6 +45791,8 @@ var init_schema2 = __esm(() => {
     completedBatches: integer("completed_batches").notNull().default(0),
     failedBatches: integer("failed_batches").notNull().default(0),
     errorCode: text("error_code"),
+    graphErrorCode: text("graph_error_code"),
+    summarizeErrorCode: text("summarize_error_code"),
     attempts: integer("attempts").notNull().default(0),
     requestedAt: timestamp("requested_at").defaultNow().notNull(),
     startedAt: timestamp("started_at"),
@@ -196414,7 +196416,8 @@ var basePipelineJobFields = {
   requestedAt: exports_external2.iso.datetime(),
   source: pipelineSourceSchema,
   refreshMode: pipelineRefreshModeSchema,
-  embeddingContextHash: exports_external2.string().min(1).optional()
+  embeddingContextHash: exports_external2.string().min(1).optional(),
+  warningRetry: exports_external2.literal(true).optional()
 };
 function normalizeLegacyPipelineJob(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
@@ -228647,6 +228650,33 @@ function encodeS3CopySource(bucket, key) {
 // ../../backend/src/api/routes/documents.ts
 init_logger3();
 
+// ../../backend/src/lib/pipeline-error.ts
+class PipelineProviderError extends Error {
+  code;
+  retryable;
+  constructor(code2, retryable, message2 = code2) {
+    super(message2);
+    this.code = code2;
+    this.retryable = retryable;
+    this.name = "PipelineProviderError";
+  }
+}
+function pipelineErrorCode(error53, fallback) {
+  if (error53 instanceof PipelineProviderError)
+    return error53.code;
+  return fallback;
+}
+function isRetryablePipelineError(code2) {
+  return new Set([
+    "provider_failure",
+    "provider_timeout",
+    "invalid_provider_response",
+    "queue_enqueue_failed",
+    "age_unavailable",
+    "age_persist_failed"
+  ]).has(code2);
+}
+
 // ../../backend/src/lib/version-prune.ts
 init_schema2();
 init_drizzle_orm();
@@ -228682,6 +228712,30 @@ async function maybePruneVersions(documentId) {
 }
 
 // ../../backend/src/api/routes/documents.ts
+init_names();
+
+// ../../backend/src/queue/pipeline-warning-retry.ts
+function resolveActiveWarningRetry(stageStarted, retryJobExists) {
+  if (!stageStarted)
+    return "enqueue";
+  return retryJobExists ? "deduplicate" : "conflict";
+}
+function warningRetryJobId(stage, generationId) {
+  return `${stage}-warning-retry-${generationId}`;
+}
+function summaryJobIdForPipeline(job2) {
+  return job2.warningRetry ? warningRetryJobId("summarize", job2.generationId) : JOB_IDS.summarize(job2.generationId, job2.workspaceId);
+}
+function planWarningStageRetry(state) {
+  const graph = state.graphStatus === "failed" && isRetryablePipelineError(state.graphErrorCode ?? "graph_failed");
+  const summarize = state.summarizeStatus === "failed" && isRetryablePipelineError(state.summarizeErrorCode ?? "summary_failed");
+  if (!graph && !summarize)
+    return null;
+  return { graph, summarize, entryStage: graph ? "graph" : "summarize" };
+}
+
+// ../../backend/src/api/routes/documents.ts
+init_queues();
 class DocumentPurgeNotFoundError extends Error {
   constructor() {
     super("document_purge_not_found");
@@ -229237,6 +229291,8 @@ var documentRoutes = new Elysia({ prefix: "/api" }).get("/documents", async ({ q
       embedStatus: documentPipelineRuns.embedStatus,
       graphStatus: documentPipelineRuns.graphStatus,
       summarizeStatus: documentPipelineRuns.summarizeStatus,
+      graphErrorCode: documentPipelineRuns.graphErrorCode,
+      summarizeErrorCode: documentPipelineRuns.summarizeErrorCode,
       finalizeStatus: documentPipelineRuns.finalizeStatus,
       totalBatches: documentPipelineRuns.totalBatches,
       completedBatches: documentPipelineRuns.completedBatches,
@@ -229266,6 +229322,22 @@ var documentRoutes = new Elysia({ prefix: "/api" }).get("/documents", async ({ q
         completed: run3.completedBatches,
         failed: run3.failedBatches
       },
+      warnings: [
+        ...run3.graphStatus === "failed" ? [
+          {
+            stage: "graph",
+            code: run3.graphErrorCode ?? "graph_failed",
+            retryable: isRetryablePipelineError(run3.graphErrorCode ?? "graph_failed")
+          }
+        ] : [],
+        ...run3.summarizeStatus === "failed" ? [
+          {
+            stage: "summarize",
+            code: run3.summarizeErrorCode ?? "summary_failed",
+            retryable: isRetryablePipelineError(run3.summarizeErrorCode ?? "summary_failed")
+          }
+        ] : []
+      ],
       updatedAt: run3.updatedAt
     };
   } catch (err) {
@@ -229273,6 +229345,194 @@ var documentRoutes = new Elysia({ prefix: "/api" }).get("/documents", async ({ q
     set2.status = 500;
     return { error: "Failed to load pipeline progress" };
   }
+}).post("/documents/:id/pipeline/retry-warnings", async ({ params: params2, set: set2, request }) => {
+  const parsedParams = documentIdParamsSchema.safeParse(params2);
+  if (!parsedParams.success) {
+    set2.status = 400;
+    return { error: "Invalid document id" };
+  }
+  const documentId = parsedParams.data.id;
+  const ip = request.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ?? request.headers.get("x-real-ip") ?? "unknown";
+  const rl = await writeRateLimiter(ip, request);
+  if (!rl.allowed) {
+    set2.status = 429;
+    set2.headers = rateLimitHeaders(0, rl.retryAfter);
+    return { error: "Too many requests" };
+  }
+  set2.headers = rateLimitHeaders(rl.remaining);
+  const access = await resolveContentAccess(request);
+  const ctx = access.ctx;
+  if (ctx.role === "none") {
+    set2.status = 401;
+    return { error: "Unauthorized" };
+  }
+  if (!canAccessContent(access, "write")) {
+    set2.status = 403;
+    return { error: "Forbidden" };
+  }
+  let claimed;
+  try {
+    const retry2 = await withTenant(ctx, async (tx) => {
+      await acquireDocumentPipelineLock(tx, documentId);
+      const [run3] = await tx.select({
+        status: documentPipelineRuns.status,
+        generationId: documentPipelineRuns.generationId,
+        revision: documentPipelineRuns.revision,
+        ownerId: documentPipelineRuns.ownerId,
+        workspaceId: documentPipelineRuns.workspaceId,
+        refreshMode: documentPipelineRuns.refreshMode,
+        embeddingContextHash: documentPipelineRuns.embeddingContextHash,
+        embedStatus: documentPipelineRuns.embedStatus,
+        graphStatus: documentPipelineRuns.graphStatus,
+        summarizeStatus: documentPipelineRuns.summarizeStatus,
+        graphErrorCode: documentPipelineRuns.graphErrorCode,
+        summarizeErrorCode: documentPipelineRuns.summarizeErrorCode
+      }).from(documentPipelineRuns).innerJoin(documents, and(eq(documents.id, documentPipelineRuns.documentId), eq(documents.activeEmbeddingGeneration, documentPipelineRuns.generationId), eq(documents.contentHash, documentPipelineRuns.revision))).where(and(eq(documentPipelineRuns.documentId, documentId), tenantOwnerCondition(documents.ownerId, documents.workspaceId, ctx), eq(documentPipelineRuns.embedStatus, "ready"), isNull(documents.deletedAt), ...access.restricted ? [
+        access.categoryId ? effectiveDocumentCategoryCondition(documents.categoryId, documents.folderId, ctx, access.categoryId) : sql`false`
+      ] : [])).orderBy(desc(documentPipelineRuns.updatedAt)).limit(1).for("update");
+      if (!run3)
+        return null;
+      if (run3.status === "processing") {
+        const graph2 = ["retrying", "processing"].includes(run3.graphStatus);
+        const summarize2 = ["retrying", "processing"].includes(run3.summarizeStatus);
+        return graph2 || summarize2 ? {
+          ...run3,
+          graph: graph2,
+          summarize: summarize2,
+          deduplicated: true,
+          stageStarted: run3.graphStatus === "processing" || run3.summarizeStatus === "processing"
+        } : null;
+      }
+      if (run3.status !== "ready_with_warnings")
+        return null;
+      const plan = planWarningStageRetry(run3);
+      if (!plan)
+        return null;
+      const { graph, summarize } = plan;
+      await tx.update(documentPipelineRuns).set({
+        status: "processing",
+        finalizeStatus: "pending",
+        ...graph ? { graphStatus: "retrying", graphErrorCode: null } : {},
+        ...summarize ? {
+          summarizeStatus: "retrying",
+          summarizeErrorCode: null
+        } : {},
+        updatedAt: new Date
+      }).where(eq(documentPipelineRuns.generationId, run3.generationId));
+      return {
+        ...run3,
+        graph,
+        summarize,
+        deduplicated: false,
+        stageStarted: false
+      };
+    });
+    if (!retry2) {
+      set2.status = 409;
+      return { error: "No retryable warning stages" };
+    }
+    if (!retry2.deduplicated)
+      claimed = retry2;
+    const stage = retry2.graph ? "graph" : "summarize";
+    const retryJobId = warningRetryJobId(stage, retry2.generationId);
+    const staleJobs = [
+      ...retry2.graph ? [
+        [
+          "graph",
+          JOB_IDS.graph(retry2.generationId, retry2.workspaceId ?? undefined)
+        ]
+      ] : [],
+      ...retry2.summarize ? [
+        [
+          "summarize",
+          JOB_IDS.summarize(retry2.generationId, retry2.workspaceId ?? undefined)
+        ]
+      ] : [],
+      [
+        "finalize",
+        JOB_IDS.finalize(retry2.generationId, retry2.workspaceId ?? undefined)
+      ]
+    ];
+    if (!retry2.deduplicated) {
+      for (const [queuedStage, jobId] of staleJobs) {
+        const oldJob = await getPipelineQueue(queuedStage, config3.REDIS_URL).getJob(jobId);
+        await oldJob?.remove();
+      }
+    }
+    const queue2 = getPipelineQueue(stage, config3.REDIS_URL);
+    const existingRetryJob = await queue2.getJob(retryJobId);
+    if (retry2.deduplicated) {
+      const activeRetry = resolveActiveWarningRetry(retry2.stageStarted, Boolean(existingRetryJob));
+      if (activeRetry === "conflict") {
+        set2.status = 409;
+        return { error: "No retryable warning stages" };
+      }
+      if (activeRetry === "deduplicate")
+        return {
+          documentId,
+          generationId: retry2.generationId,
+          deduplicated: true,
+          retriedStages: [
+            ...retry2.graph ? ["graph"] : [],
+            ...retry2.summarize ? ["summarize"] : []
+          ]
+        };
+    }
+    const existingRetryState = await existingRetryJob?.getState();
+    if (existingRetryState === "completed" || existingRetryState === "failed") {
+      await existingRetryJob?.remove();
+    }
+    const data = {
+      schemaVersion: PIPELINE_SCHEMA_VERSION,
+      stage,
+      documentId,
+      ownerId: retry2.ownerId,
+      ...retry2.workspaceId ? { workspaceId: retry2.workspaceId } : {},
+      generationId: retry2.generationId,
+      revision: retry2.revision,
+      requestedAt: new Date().toISOString(),
+      source: "api",
+      refreshMode: retry2.refreshMode === "incremental" ? "incremental" : "full",
+      ...retry2.embeddingContextHash ? { embeddingContextHash: retry2.embeddingContextHash } : {},
+      warningRetry: true
+    };
+    await queue2.add(stage, data, {
+      ...DEFAULT_JOB_OPTIONS,
+      jobId: retryJobId,
+      priority: SOURCE_PRIORITY.api
+    });
+    return {
+      documentId,
+      generationId: retry2.generationId,
+      deduplicated: retry2.deduplicated,
+      retriedStages: [
+        ...retry2.graph ? ["graph"] : [],
+        ...retry2.summarize ? ["summarize"] : []
+      ]
+    };
+  } catch (err) {
+    const failedClaim = claimed;
+    if (failedClaim) {
+      await withTenant(ctx, (tx) => tx.update(documentPipelineRuns).set({
+        status: "ready_with_warnings",
+        finalizeStatus: "ready",
+        ...failedClaim.graph ? {
+          graphStatus: "failed",
+          graphErrorCode: "queue_enqueue_failed"
+        } : {},
+        ...failedClaim.summarize ? {
+          summarizeStatus: "failed",
+          summarizeErrorCode: "queue_enqueue_failed"
+        } : {},
+        updatedAt: new Date
+      }).where(and(eq(documentPipelineRuns.generationId, failedClaim.generationId), eq(documentPipelineRuns.status, "processing")))).catch(() => {
+        return;
+      });
+    }
+    logger3.error({ err, documentId }, "Failed to retry warning stages");
+    set2.status = 500;
+    return { error: "Failed to retry warning stages" };
+  }
 }).get("/documents/:id/knowledge-summary", async ({ params: params2, set: set2, request }) => {
   const parsedParams = documentIdParamsSchema.safeParse(params2);
   if (!parsedParams.success) {
@@ -229362,6 +229622,8 @@ var documentRoutes = new Elysia({ prefix: "/api" }).get("/documents", async ({ q
       embedStatus: documentPipelineRuns.embedStatus,
       graphStatus: documentPipelineRuns.graphStatus,
       summarizeStatus: documentPipelineRuns.summarizeStatus,
+      graphErrorCode: documentPipelineRuns.graphErrorCode,
+      summarizeErrorCode: documentPipelineRuns.summarizeErrorCode,
       finalizeStatus: documentPipelineRuns.finalizeStatus,
       totalBatches: documentPipelineRuns.totalBatches,
       completedBatches: documentPipelineRuns.completedBatches,
@@ -229405,6 +229667,22 @@ var documentRoutes = new Elysia({ prefix: "/api" }).get("/documents", async ({ q
         completed: run3.completedBatches,
         failed: run3.failedBatches
       },
+      warnings: [
+        ...run3.graphStatus === "failed" ? [
+          {
+            stage: "graph",
+            code: run3.graphErrorCode ?? "graph_failed",
+            retryable: isRetryablePipelineError(run3.graphErrorCode ?? "graph_failed")
+          }
+        ] : [],
+        ...run3.summarizeStatus === "failed" ? [
+          {
+            stage: "summarize",
+            code: run3.summarizeErrorCode ?? "summary_failed",
+            retryable: isRetryablePipelineError(run3.summarizeErrorCode ?? "summary_failed")
+          }
+        ] : []
+      ],
       updatedAt: run3.updatedAt
     } : null
   };
@@ -232252,22 +232530,40 @@ function uniqueChatProviders(providers) {
   return unique;
 }
 async function requestStructuredChat(options) {
+  const attempt = await requestStructuredChatDetailed(options);
+  return attempt.ok ? attempt.result : null;
+}
+async function requestStructuredChatDetailed(options) {
   const providers = uniqueChatProviders([
     options.primary,
     options.fallback,
     ...options.fallbacks ?? []
   ]);
+  let lastError = new PipelineProviderError("provider_unavailable", false, "No chat provider was configured");
   for (const provider of providers) {
     try {
       const raw = await requestChatContent(provider, options);
-      const parsed = parseJson(raw);
+      let parsed;
+      try {
+        parsed = parseJson(raw);
+      } catch {
+        lastError = new PipelineProviderError("invalid_provider_response", true);
+        continue;
+      }
       const result = options.outputSchema.safeParse(parsed);
-      if (!result.success)
+      if (!result.success) {
+        lastError = new PipelineProviderError("permanent_validation_failure", false);
         continue;
-      return { data: result.data, model: provider.model };
-    } catch {}
+      }
+      return {
+        ok: true,
+        result: { data: result.data, model: provider.model }
+      };
+    } catch (error53) {
+      lastError = error53 instanceof PipelineProviderError ? error53 : error53 instanceof Error && error53.name === "AbortError" ? new PipelineProviderError("provider_timeout", true) : new PipelineProviderError("provider_failure", true);
+    }
   }
-  return null;
+  return { ok: false, error: lastError };
 }
 async function requestChatContent(provider, options) {
   const controller = new AbortController;
@@ -232292,11 +232588,16 @@ async function requestChatContent(provider, options) {
       })
     });
     if (!response.ok)
-      throw new Error(`chat provider returned ${response.status}`);
-    const body = await response.json();
+      throw new PipelineProviderError("provider_failure", true, `chat provider returned ${response.status}`);
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      throw new PipelineProviderError("invalid_provider_response", true);
+    }
     const content50 = body.choices?.[0]?.message?.content;
     if (typeof content50 !== "string" || !content50.trim()) {
-      throw new Error("chat provider returned empty content");
+      throw new PipelineProviderError("invalid_provider_response", true);
     }
     return content50;
   } finally {
@@ -232573,18 +232874,21 @@ function rerankUrl(baseUrl) {
   return normalized.endsWith("/rerank") ? normalized : `${normalized}/rerank`;
 }
 async function requestRerank(input) {
-  const documents2 = input.candidates.map((candidate) => candidate.text.trim()).filter((text4) => text4.length > 0);
-  if (documents2.length === 0)
+  const candidates = input.candidates.map((candidate, originalIndex) => ({
+    id: candidate.id,
+    document: candidate.text.trim(),
+    originalIndex
+  })).filter((candidate) => candidate.document.length > 0);
+  if (candidates.length === 0)
     return null;
-  const ids = input.candidates.map((candidate) => candidate.id);
-  const topN = Math.min(input.topN ?? config3.SEARCH_RERANK_TOP_N, documents2.length);
+  const topN = Math.min(input.topN ?? config3.SEARCH_RERANK_TOP_N, candidates.length);
   const timeoutMs = config3.SEARCH_RERANK_TIMEOUT_MS;
   const started = performance.now();
-  incrementCounterBy(METRIC_NAMES.SEARCH_RERANK_CANDIDATES_TOTAL, documents2.length);
+  incrementCounterBy(METRIC_NAMES.SEARCH_RERANK_CANDIDATES_TOTAL, candidates.length);
   try {
     for (const slot of configuredSlots()) {
       try {
-        const hits = await callRerankSlot(slot, input.query, documents2, ids, {
+        const hits = await callRerankSlot(slot, input.query, candidates, {
           topN,
           timeoutMs
         });
@@ -232602,7 +232906,7 @@ async function requestRerank(input) {
     recordDuration(METRIC_NAMES.SEARCH_RERANK_DURATION_MS, performance.now() - started);
   }
 }
-async function callRerankSlot(slot, query, documents2, ids, options) {
+async function callRerankSlot(slot, query, candidates, options) {
   const controller = new AbortController;
   const timer2 = setTimeout(() => controller.abort(), options.timeoutMs);
   const headers = {
@@ -232618,7 +232922,7 @@ async function callRerankSlot(slot, query, documents2, ids, options) {
       body: JSON.stringify({
         model: slot.model,
         query,
-        documents: documents2,
+        documents: candidates.map((candidate) => candidate.document),
         top_n: options.topN
       })
     });
@@ -232627,14 +232931,16 @@ async function callRerankSlot(slot, query, documents2, ids, options) {
     }
     const body = await response.json();
     const hits = [];
+    const seenIds = new Set;
     for (const [rank, row] of (body.results ?? []).entries()) {
-      if (typeof row.index !== "number" || row.index < 0)
+      if (typeof row.index !== "number" || !Number.isInteger(row.index) || row.index < 0)
         continue;
-      const id3 = ids[row.index];
-      if (!id3)
+      const candidate = candidates[row.index];
+      if (!candidate || seenIds.has(candidate.id))
         continue;
+      seenIds.add(candidate.id);
       const score = typeof row.relevance_score === "number" && Number.isFinite(row.relevance_score) ? row.relevance_score : 0;
-      hits.push({ id: id3, score, rank: rank + 1 });
+      hits.push({ id: candidate.id, score, rank: rank + 1 });
     }
     return hits;
   } finally {
@@ -235895,7 +236201,11 @@ async function extractEntities(chunkText2, documentId, options = {}) {
     } catch (err) {
       await releaseDedupClaim();
       logger3.warn({ err, documentId }, "Entity extraction LLM call failed \u2014 skipping");
-      return { status: "failed", warning: "provider_failed", entities: [] };
+      return {
+        status: "failed",
+        warning: err instanceof Error && err.message ? err.message : "provider_failure",
+        entities: []
+      };
     }
   }
   if (entities === null) {
@@ -235994,7 +236304,7 @@ async function callEntityExtractionLLM(text4, options) {
   const [primary, ...fallbacks] = providers;
   if (!primary)
     return null;
-  const result = await requestStructuredChat({
+  const attempt = await requestStructuredChatDetailed({
     primary,
     fallbacks,
     messages: [
@@ -236005,7 +236315,9 @@ async function callEntityExtractionLLM(text4, options) {
     maxTokens: options.maxTokens ?? DEFAULT_MAX_TOKENS,
     temperature: options.temperature ?? DEFAULT_TEMPERATURE
   });
-  return result ? parseExtractionResponse(JSON.stringify(result.data)) : null;
+  if (!attempt.ok)
+    throw attempt.error;
+  return parseExtractionResponse(JSON.stringify(attempt.result.data));
 }
 function resolveGraphProviderKey(baseUrl, explicitKey) {
   return resolveChatProviderKey(baseUrl, explicitKey, config3.OPENROUTER_API_KEY);
@@ -236199,11 +236511,11 @@ async function buildKnowledgeSummary(document2, provider) {
   }
   const output = await provider(document2);
   if (!output)
-    throw new Error("summary_provider_failed");
+    throw new Error("provider_failure");
   const language = output.language.trim();
   const description = output.description.trim();
   if (!language || !description)
-    throw new Error("summary_provider_invalid");
+    throw new Error("permanent_validation_failure");
   const seen = new Set;
   const keywords = [];
   for (const raw of output.keywords) {
@@ -236258,7 +236570,7 @@ async function requestKnowledgeSummary(document2) {
     provider(config3.GRAPH_EXTRACT_FALLBACK_BASE_URL, config3.GRAPH_EXTRACT_FALLBACK_API_KEY, config3.GRAPH_EXTRACT_FALLBACK_MODEL),
     provider(config3.GRAPH_EXTRACT_FALLBACK_2_BASE_URL, config3.GRAPH_EXTRACT_FALLBACK_2_API_KEY, config3.GRAPH_EXTRACT_FALLBACK_2_MODEL)
   ].filter((item) => Boolean(item));
-  const result = await requestStructuredChat({
+  const attempt = await requestStructuredChatDetailed({
     primary,
     fallbacks,
     messages: [
@@ -236274,7 +236586,9 @@ ${document2.content.slice(0, 50000)}`
     maxTokens: 768,
     temperature: 0
   });
-  return result ? { ...result.data, model: result.model } : null;
+  if (!attempt.ok)
+    throw attempt.error;
+  return { ...attempt.result.data, model: attempt.result.model };
 }
 
 // ../../backend/src/queue/document-revision.ts
@@ -236775,6 +237089,14 @@ function stagePatch(stage, status2) {
     return { summarizeStatus: status2 };
   return { finalizeStatus: status2 };
 }
+function stageErrorPatch(stage, status2, errorCode) {
+  const value = status2 === "failed" ? errorCode ?? "unknown_failure" : null;
+  if (stage === "graph")
+    return { graphErrorCode: value };
+  if (stage === "summarize")
+    return { summarizeErrorCode: value };
+  return {};
+}
 function pipelineStageStatus(value) {
   return value === "ready_with_warnings" ? "failed" : value;
 }
@@ -236804,6 +237126,7 @@ async function cancelStalePipelineRun(job2, errorCode = "stale_revision") {
 async function setStageStatus(generationId, stage, status2, errorCode) {
   await withTenant(admin, (tx) => tx.update(documentPipelineRuns).set({
     ...stagePatch(stage, status2),
+    ...stageErrorPatch(stage, status2, errorCode),
     ...errorCode ? { errorCode } : {},
     updatedAt: new Date
   }).where(and(eq(documentPipelineRuns.generationId, generationId), ne(documentPipelineRuns.status, "cancelled"))));
@@ -237114,7 +237437,8 @@ function createPipelineStageDependencies(redisUrl) {
           generationId: run3.generationId,
           revision: run3.revision,
           embeddingContextHash: run3.embeddingContextHash ?? undefined,
-          embedStatus: pipelineStageStatus(run3.embedStatus)
+          embedStatus: pipelineStageStatus(run3.embedStatus),
+          summarizeStatus: pipelineStageStatus(run3.summarizeStatus)
         } : null;
       },
       async extract(job2) {
@@ -237142,7 +237466,15 @@ function createPipelineStageDependencies(redisUrl) {
         const data = { ...job2, stage: "summarize" };
         await enqueueIfActive("summarize", "summarize", data, {
           ...DEFAULT_JOB_OPTIONS,
-          jobId: JOB_IDS.summarize(job2.generationId, job2.workspaceId),
+          jobId: summaryJobIdForPipeline(job2),
+          priority: SOURCE_PRIORITY[job2.source]
+        });
+      },
+      async enqueueFinalize(job2) {
+        const data = { ...job2, stage: "finalize" };
+        await enqueueIfActive("finalize", "finalize", data, {
+          ...DEFAULT_JOB_OPTIONS,
+          jobId: `${JOB_IDS.finalize(job2.generationId, job2.workspaceId)}-graph-retry-${job2.requestedAt.replace(/\D/g, "")}`,
           priority: SOURCE_PRIORITY[job2.source]
         });
       }
@@ -237637,10 +237969,12 @@ async function processSummaryStage(job2, dependencies) {
   } catch (error53) {
     if (!await continueIfCurrent())
       return;
-    await dependencies.setSummaryStatus(job2.generationId, "failed", error53 instanceof Error ? error53.name : "summary_failed");
+    await dependencies.setSummaryStatus(job2.generationId, "failed", pipelineErrorCode(error53, "summary_failed"));
     if (!await continueIfCurrent())
       return;
     await dependencies.enqueueFinalize(job2);
+    if (error53 instanceof PipelineProviderError && error53.retryable)
+      throw error53;
     return;
   }
   if (!await continueIfCurrent())
@@ -237655,7 +237989,7 @@ async function processGraphStageFailure(job2, error53, dependencies) {
   }
   if (await dependencies.isCancelled?.(job2))
     throw error53;
-  await dependencies.setGraphStatus(job2.generationId, "failed", error53 instanceof Error ? error53.name : "graph_failed");
+  await dependencies.setGraphStatus(job2.generationId, "failed", pipelineErrorCode(error53, "graph_failed"));
   if (!await dependencies.isCancelled?.(job2)) {
     await dependencies.enqueueSummarize(job2);
   }
@@ -237689,6 +238023,18 @@ function createGraphWorker(deps) {
     const run3 = await deps.getRun(job2);
     if (!run3)
       throw new Error("Pipeline run not found");
+    const continuePipeline = async () => {
+      if (await deps.isCancelled?.(job2))
+        return;
+      if (run3.summarizeStatus === "ready" || run3.summarizeStatus === "skipped") {
+        if (deps.enqueueFinalize)
+          await deps.enqueueFinalize(job2);
+        else
+          await deps.enqueueSummarize(job2);
+        return;
+      }
+      await deps.enqueueSummarize(job2);
+    };
     if (run3.ownerId !== job2.ownerId || run3.documentId !== job2.documentId) {
       throw new Error("Pipeline owner mismatch");
     }
@@ -237706,8 +238052,7 @@ function createGraphWorker(deps) {
       if (await deps.isCancelled?.(job2))
         return;
       await deps.setGraphStatus(job2.generationId, "skipped", "embedding_not_ready");
-      if (!await deps.isCancelled?.(job2))
-        await deps.enqueueSummarize(job2);
+      await continuePipeline();
       return;
     }
     if (await deps.isCancelled?.(job2))
@@ -237727,15 +238072,27 @@ function createGraphWorker(deps) {
         return;
       }
       if (outcome.status === "unavailable" || outcome.status === "failed") {
+        if (outcome.status === "failed" && [
+          "provider_failure",
+          "provider_timeout",
+          "invalid_provider_response"
+        ].includes(outcome.warning)) {
+          throw new PipelineProviderError(outcome.warning, true);
+        }
         await deps.setGraphStatus(job2.generationId, "failed", outcome.warning);
-        if (!await deps.isCancelled?.(job2))
-          await deps.enqueueSummarize(job2);
+        await continuePipeline();
         return;
       }
       await deps.setGraphStatus(job2.generationId, "ready");
-      if (!await deps.isCancelled?.(job2))
-        await deps.enqueueSummarize(job2);
+      await continuePipeline();
     } catch (error53) {
+      if (error53 instanceof PipelineProviderError) {
+        await deps.setGraphStatus(job2.generationId, "failed", error53.code);
+        await continuePipeline();
+        if (error53.retryable)
+          throw error53;
+        return;
+      }
       await processGraphStageFailure(job2, error53, deps);
     }
   };
@@ -237942,7 +238299,7 @@ var swaggerConfig = {
     },
     info: {
       title: "DocsMint API",
-      version: "0.8.1",
+      version: "0.8.2",
       description: "Self-hosted AI-native knowledge workspace and installable PWA with hybrid search, GraphRAG, REST, SDK, CLI, and MCP access for people and AI agents.",
       contact: { name: "HiAi-gg", url: "https://github.com/HiAi-gg/docsmint" },
       license: {

package/dist/backend-account-runtime-cleanup.js

@@ -284,6 +284,8 @@ var documentPipelineRuns = pgTable("document_pipeline_runs", {
   completedBatches: integer("completed_batches").notNull().default(0),
   failedBatches: integer("failed_batches").notNull().default(0),
   errorCode: text("error_code"),
+  graphErrorCode: text("graph_error_code"),
+  summarizeErrorCode: text("summarize_error_code"),
   attempts: integer("attempts").notNull().default(0),
   requestedAt: timestamp("requested_at").defaultNow().notNull(),
   startedAt: timestamp("started_at"),