@cartanova/qgrid-cli 2.6.10 → 2.6.11

package/bundle/dist/i18n/ko.js

@@ -48,8 +48,10 @@ var ko_default = {
 	"error.serviceUnavailable": "서비스를 사용할 수 없습니다",
 	"setting.invalidValue": (reason) => `설정 값이 올바르지 않습니다: ${reason}`,
 	"setting.unknownKey": (key) => `알 수 없는 설정 키 ${key}`,
+	"setting.noSupervisor": () => "로컬 실행 환경에서는 재시작할 수 없습니다 — 종료하면 다시 켜줄 모니터링 도구가 없습니다",
 	"qgrid.dispatcherFailed": (provider) => `${provider} dispatcher 초기화에 실패했습니다`,
 	"qgrid.dispatcherStarting": (provider) => `${provider} dispatcher 기동 중입니다. 잠시 후 다시 시도해주세요`,
+	"qgrid.restartPending": () => "서버 재시작 중입니다. 잠시 후 다시 시도해주세요",
 	"error.unauthorized": "인증이 필요합니다",
 	"error.unknownSearchField": (field) => `구현되지 않은 검색 필드 ${field}`,
 	notFound: (name, id) => `존재하지 않는 ${name} ID ${id}`,
@@ -62,4 +64,4 @@ var ko_default = {
 //#endregion
 export { ko_default as default };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/dist/utils/process-supervisor.js

@@ -0,0 +1,22 @@
+//#region src/utils/process-supervisor.ts
+/**
+* 프로세스 모니터링 도구 감지.
+*
+* 화면의 "재시작"은 스스로를 종료하는 것이다 — pm2 같은 도구가 죽은 프로세스를 다시
+* 띄워주는 것이 곧 재시작이다. 그래서 그런 도구 없이 종료하면 그냥 서버가 내려간다.
+* 로컬 개발에서 버튼을 누르면 아무도 살려주지 않으므로, 종료 전에 반드시 확인한다.
+*
+* 현재 배포 계약은 pm2 만 재시작을 보장한다. systemd 의 `INVOCATION_ID` 는 해당
+* unit 이 `Restart=` 를 쓴다는 뜻이 아니므로 안전한 감독자 신호로 사용할 수 없다.
+*
+* 값이 아니라 존재 여부가 신호다. pm2 는 첫 프로세스에 `pm_id=0` 을 주므로 truthy 검사로
+* 판별하면 놓친다.
+*/
+function detectSupervisor(env = process.env) {
+	if (env.pm_id !== void 0) return "pm2";
+	return null;
+}
+//#endregion
+export { detectSupervisor };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvY2Vzcy1zdXBlcnZpc29yLmpzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9wcm9jZXNzLXN1cGVydmlzb3IudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiDtlITroZzshLjsiqQg66qo64uI7YSw66eBIOuPhOq1rCDqsJDsp4AuXG4gKlxuICog7ZmU66m07J2YIFwi7J6s7Iuc7J6RXCLsnYAg7Iqk7Iqk66Gc66W8IOyiheujjO2VmOuKlCDqsoPsnbTri6Qg4oCUIHBtMiDqsJnsnYAg64+E6rWs6rCAIOyjveydgCDtlITroZzshLjsiqTrpbwg64uk7IucXG4gKiDrnYTsm4zso7zripQg6rKD7J20IOqzpyDsnqzsi5zsnpHsnbTri6QuIOq3uOuemOyEnCDqt7jrn7Ag64+E6rWsIOyXhuydtCDsooXro4ztlZjrqbQg6re464OlIOyEnOuyhOqwgCDrgrTroKTqsITri6QuXG4gKiDroZzsu6wg6rCc67Cc7JeQ7IScIOuyhO2KvOydhCDriITrpbTrqbQg7JWE66y064+EIOyCtOugpOyjvOyngCDslYrsnLzrr4DroZwsIOyiheujjCDsoITsl5Ag67CY65Oc7IucIO2ZleyduO2VnOuLpC5cbiAqXG4gKiDtmITsnqwg67Cw7Y+sIOqzhOyVveydgCBwbTIg66eMIOyerOyLnOyekeydhCDrs7TsnqXtlZzri6QuIHN5c3RlbWQg7J2YIGBJTlZPQ0FUSU9OX0lEYCDripQg7ZW064u5XG4gKiB1bml0IOydtCBgUmVzdGFydD1gIOulvCDsk7Tri6TripQg65y77J20IOyVhOuLiOuvgOuhnCDslYjsoITtlZwg6rCQ64+F7J6QIOyLoO2YuOuhnCDsgqzsmqntlaAg7IiYIOyXhuuLpC5cbiAqXG4gKiDqsJLsnbQg7JWE64uI6528IOyhtOyerCDsl6zrtoDqsIAg7Iug7Zi464ukLiBwbTIg64qUIOyyqyDtlITroZzshLjsiqTsl5AgYHBtX2lkPTBgIOydhCDso7zrr4DroZwgdHJ1dGh5IOqygOyCrOuhnFxuICog7YyQ67OE7ZWY66m0IOuGk+y5nOuLpC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGRldGVjdFN1cGVydmlzb3IoZW52OiBOb2RlSlMuUHJvY2Vzc0VudiA9IHByb2Nlc3MuZW52KTogXCJwbTJcIiB8IG51bGwge1xuICBpZiAoZW52LnBtX2lkICE9PSB1bmRlZmluZWQpIHJldHVybiBcInBtMlwiO1xuICByZXR1cm4gbnVsbDtcbn1cbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7QUFhQSxTQUFnQixpQkFBaUIsTUFBeUIsUUFBUSxLQUFtQjtDQUNuRixJQUFJLElBQUksVUFBVSxRQUFXLE9BQU87Q0FDcEMsT0FBTztBQUNUIn0=

package/bundle/dist/utils/server-restart.js

@@ -0,0 +1,61 @@
+//#region src/utils/server-restart.ts
+const RESTART_EXIT_FALLBACK_MS = 5e3;
+let restartPending = false;
+let exitTriggered = false;
+let exitArmed = false;
+let fallbackTimer;
+let armedReplyRaw;
+let armedExit;
+/** 재시작 요청 뒤에는 새 native provider 실행을 받지 않는다. */
+function isRestartPending() {
+	return restartPending;
+}
+/**
+* 프로세스 전체에서 최초 요청만 재시작을 시작한다. 종료 신호는 active run 정합성 처리가
+* 끝난 뒤 별도로 arm 한다. 그래야 이미 닫힌 연결이나 fallback 타이머가 DB 정리보다 앞서
+* 프로세스를 끝내지 않는다.
+*/
+function beginServerRestart() {
+	if (restartPending) return false;
+	restartPending = true;
+	return true;
+}
+function clearExitArm() {
+	if (fallbackTimer) clearTimeout(fallbackTimer);
+	fallbackTimer = void 0;
+	if (armedReplyRaw && armedExit) {
+		armedReplyRaw.removeListener("finish", armedExit);
+		armedReplyRaw.removeListener("close", armedExit);
+	}
+	armedReplyRaw = void 0;
+	armedExit = void 0;
+}
+/** 정합성 처리가 끝난 뒤 HTTP 응답 flush/연결 종료/유한 fallback 중 먼저 온 신호로 종료한다. */
+function armServerRestartExit(replyRaw) {
+	if (!restartPending || exitArmed) return;
+	exitArmed = true;
+	const exitOnce = () => {
+		if (exitTriggered) return;
+		exitTriggered = true;
+		clearExitArm();
+		process.exit(0);
+	};
+	armedReplyRaw = replyRaw;
+	armedExit = exitOnce;
+	replyRaw.once("finish", exitOnce);
+	replyRaw.once("close", exitOnce);
+	fallbackTimer = setTimeout(exitOnce, RESTART_EXIT_FALLBACK_MS);
+	fallbackTimer.unref();
+	if (replyRaw.destroyed && !replyRaw.writableEnded) exitOnce();
+}
+/** 모듈 전역 상태를 격리해야 하는 단위 테스트 전용. */
+function resetServerRestartForTests() {
+	clearExitArm();
+	restartPending = false;
+	exitTriggered = false;
+	exitArmed = false;
+}
+//#endregion
+export { armServerRestartExit, beginServerRestart, isRestartPending, resetServerRestartForTests };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/src/application/qgrid/qgrid-oauth-redirect.test.ts

@@ -52,6 +52,13 @@ vi.mock("../token/token.model", () => ({
   },
 }));
 
+// OAuth 리다이렉트 테스트는 token-death를 검증하지 않는다. 부분 TokenModel mock이
+// isolate:false 워커의 token-death 전용 테스트로 새지 않게 실제 모듈 로드를 막는다.
+vi.mock("./token-death", () => ({
+  deactivateAuthDeadToken: vi.fn(),
+  notifyTokenAdded: vi.fn(),
+}));
+
 function authUrlParam(authUrl: string, key: string): string | null {
   return new URL(authUrl).searchParams.get(key);
 }

package/bundle/src/application/qgrid/qgrid-run-lifecycle.test.ts

@@ -1,10 +1,16 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
+import {
+  beginServerRestart,
+  resetServerRestartForTests,
+} from "../../utils/server-restart";
 import {
   afterQuery,
   beforeQuery,
+  finishActiveNativeRunsForRestart,
   finishRunAborted,
   finishRunWithError,
+  resetNativeRunRegistryForTests,
 } from "./qgrid-run-lifecycle";
 import { type QueryOutput } from "./qgrid.types";
 
@@ -58,6 +64,11 @@ function queryOutput(overrides: Partial<QueryOutput> = {}): QueryOutput {
 
 let lifecycleNow = Date.now();
 
+afterEach(() => {
+  resetServerRestartForTests();
+  resetNativeRunRegistryForTests();
+});
+
 describe("qgrid run lifecycle start", () => {
   beforeEach(() => {
     lifecycleNow += 60_001;
@@ -188,6 +199,108 @@ describe("qgrid run lifecycle start", () => {
     expect(expireStaleToolWaitingRunsMock).toHaveBeenCalledTimes(1);
     expect(createRunMock).toHaveBeenCalledTimes(2);
   });
+
+  it("rejects new native runs while a restart is pending", async () => {
+    beginServerRestart();
+
+    await expect(beforeQuery({ prompt: "hi" })).rejects.toMatchObject({ statusCode: 503 });
+    expect(createRunMock).not.toHaveBeenCalled();
+  });
+
+  it("finishes a run prepared during the restart race before rejecting provider execution", async () => {
+    let resolveCreate!: (requestLogId: number) => void;
+    createRunMock.mockReturnValueOnce(
+      new Promise<number>((resolve) => {
+        resolveCreate = resolve;
+      }),
+    );
+
+    const starting = beforeQuery({ prompt: "hi" });
+    await vi.waitFor(() => expect(createRunMock).toHaveBeenCalledOnce());
+    beginServerRestart();
+    resolveCreate(22);
+
+    await expect(starting).rejects.toMatchObject({ statusCode: 503 });
+    expect(finishRunMock).toHaveBeenCalledWith(
+      22,
+      expect.objectContaining({ status: "error", error_message: "server restarted" }),
+    );
+  });
+
+  it("marks only active native runs as restarted and prevents a late success overwrite", async () => {
+    const { requestLogId, stepIndex } = await beforeQuery({ prompt: "hi" });
+
+    await finishActiveNativeRunsForRestart();
+    expect(finishRunMock).toHaveBeenCalledWith(
+      requestLogId,
+      expect.objectContaining({ status: "error", error_message: "server restarted" }),
+    );
+
+    appendStepMock.mockClear();
+    finishRunMock.mockClear();
+    await expect(afterQuery(requestLogId, stepIndex, { prompt: "hi" }, queryOutput())).resolves.toEqual(
+      {},
+    );
+    expect(appendStepMock).not.toHaveBeenCalled();
+    expect(finishRunMock).not.toHaveBeenCalled();
+  });
+
+  it("waits for an in-flight finalizer and writes the restart error last", async () => {
+    const { requestLogId, stepIndex } = await beforeQuery({ prompt: "hi" });
+    let releaseAppend!: () => void;
+    appendStepMock.mockReturnValueOnce(
+      new Promise<void>((resolve) => {
+        releaseAppend = resolve;
+      }),
+    );
+
+    const finishing = afterQuery(requestLogId, stepIndex, { prompt: "hi" }, queryOutput());
+    await vi.waitFor(() => expect(appendStepMock).toHaveBeenCalledOnce());
+    const restarting = finishActiveNativeRunsForRestart();
+
+    await Promise.resolve();
+    expect(finishRunMock).not.toHaveBeenCalledWith(
+      requestLogId,
+      expect.objectContaining({ error_message: "server restarted" }),
+    );
+
+    releaseAppend();
+    await Promise.all([finishing, restarting]);
+
+    const terminalStatuses = finishRunMock.mock.calls
+      .filter(([id]) => id === requestLogId)
+      .map(([, payload]) => payload.status);
+    expect(terminalStatuses.at(-1)).toBe("error");
+    expect(finishRunMock).toHaveBeenLastCalledWith(
+      requestLogId,
+      expect.objectContaining({ status: "error", error_message: "server restarted" }),
+    );
+  });
+
+  it("leaves tool-wait runs alone after their provider turn has completed", async () => {
+    const { requestLogId, stepIndex } = await beforeQuery({ prompt: "use a tool" });
+    await afterQuery(
+      requestLogId,
+      stepIndex,
+      { prompt: "use a tool" },
+      queryOutput({
+        finishReason: "tool-calls",
+        content: [
+          {
+            type: "tool-call",
+            toolCallId: "call-1",
+            toolName: "lookup",
+            input: "{}",
+          },
+        ],
+      }),
+    );
+    finishRunMock.mockClear();
+
+    await finishActiveNativeRunsForRestart();
+
+    expect(finishRunMock).not.toHaveBeenCalled();
+  });
 });
 
 describe("qgrid run lifecycle TTFT", () => {

package/bundle/src/application/qgrid/qgrid-run-lifecycle.ts

@@ -1,5 +1,8 @@
 import { getLogger } from "@logtape/logtape";
+import { ServiceUnavailableException } from "sonamu";
 
+import { SD } from "../../i18n/sd.generated";
+import { isRestartPending } from "../../utils/server-restart";
 import { RequestLogModel } from "../request-log/request-log.model";
 import {
   estimateImageGenerationCostMicroUsd,
@@ -17,6 +20,43 @@ const STALE_RUN_THRESHOLD_MS = 30 * 60 * 1000;
 const STALE_CLEANUP_INTERVAL_MS = 60 * 1000;
 let staleCleanupInFlight: Promise<void> | undefined;
 let lastStaleCleanupStartedAt = 0;
+const activeNativeRunRefs = new Map<number, number>();
+const interruptedNativeRunIds = new Set<number>();
+const activeNativeFinalizers = new Map<number, Set<Promise<void>>>();
+
+function restartUnavailable(): ServiceUnavailableException {
+  return new ServiceUnavailableException(SD("qgrid.restartPending")());
+}
+
+function registerNativeRun(requestLogId: number): void {
+  activeNativeRunRefs.set(requestLogId, (activeNativeRunRefs.get(requestLogId) ?? 0) + 1);
+}
+
+function releaseNativeRun(requestLogId: number): void {
+  const refs = activeNativeRunRefs.get(requestLogId);
+  if (refs === undefined || refs <= 1) activeNativeRunRefs.delete(requestLogId);
+  else activeNativeRunRefs.set(requestLogId, refs - 1);
+}
+
+function trackNativeFinalizer<T>(requestLogId: number, finalize: () => Promise<T>): Promise<T> {
+  const operation = finalize();
+  const settled = operation.then(
+    () => undefined,
+    () => undefined,
+  );
+  const finalizers = activeNativeFinalizers.get(requestLogId) ?? new Set<Promise<void>>();
+  finalizers.add(settled);
+  activeNativeFinalizers.set(requestLogId, finalizers);
+  void settled.then(() => {
+    finalizers.delete(settled);
+    if (finalizers.size === 0) activeNativeFinalizers.delete(requestLogId);
+  });
+  return operation;
+}
+
+export function assertNativeRunAdmission(): void {
+  if (isRestartPending()) throw restartUnavailable();
+}
 
 function withProviderPrefix(
   routeModel: string | undefined,
@@ -61,6 +101,8 @@ export async function beforeQuery(args: QueryInput): Promise<{
   requestLogId: number;
   stepIndex: number;
 }> {
+  assertNativeRunAdmission();
+
   let requestLogId: number;
   let stepIndex = 0;
 
@@ -88,6 +130,14 @@ export async function beforeQuery(args: QueryInput): Promise<{
     });
   }
 
+  // DB 준비 중에 재시작이 시작됐다면 provider 실행으로 넘어가지 않는다.
+  // 이 요청은 재시작 snapshot에 없었으므로 방금 준비한 run을 직접 마감한다.
+  if (isRestartPending()) {
+    await finishTerminalRun(requestLogId, "error", "server restarted");
+    throw restartUnavailable();
+  }
+
+  registerNativeRun(requestLogId);
   return { requestLogId, stepIndex };
 }
 
@@ -97,87 +147,97 @@ export async function afterQuery(
   args: QueryInput,
   result: QueryOutput,
 ): Promise<RunLifecycleResult> {
-  // provider가 canonical model을 돌려줘도 요청 route 자체([1m] 등)는 보존한다.
-  const requestedModelName = withProviderPrefix(
-    args.model,
-    args.model ?? result.requestedModel ?? result.model,
-  );
-  const servedModelName = withProviderPrefix(args.model, result.model);
-
-  // generate step 기록
-  await RequestLogModel.appendStep(requestLogId, {
-    step_index: stepIndex,
-    type: "generate",
-    model_name: servedModelName,
-    requested_model_name: requestedModelName,
-    fallback_count: result.modelFallbacks?.length ?? 0,
-    input_tokens: result.usage.input_tokens,
-    output_tokens: result.usage.output_tokens,
-    cache_read_tokens: result.usage.cache_read_input_tokens,
-    cache_creation_tokens: result.usage.cache_creation_input_tokens,
-    cache_creation_5m_tokens: result.usage.cache_creation_5m_input_tokens,
-    cache_creation_1h_tokens: result.usage.cache_creation_1h_input_tokens,
-    cost_usd: Math.round(result.costUsd * 1_000_000),
-    cost_source: result.costSource,
-    duration_ms: result.durationMs,
-    ttft_ms: result.ttftMs,
-    finish_reason: result.finishReason,
-  });
+  if (interruptedNativeRunIds.has(requestLogId)) return {};
 
-  const imageParts = getImageParts(result);
-  const imageCostMicroUsd = estimateImageGenerationCostMicroUsd(
-    result,
-    args.imageGenerationOptions,
-  );
-  for (const step of buildImageGenerationToolSteps(args, imageParts, stepIndex)) {
-    await RequestLogModel.appendStep(requestLogId, step);
-  }
+  return trackNativeFinalizer(requestLogId, async () => {
+    try {
+      // provider가 canonical model을 돌려줘도 요청 route 자체([1m] 등)는 보존한다.
+      const requestedModelName = withProviderPrefix(
+        args.model,
+        args.model ?? result.requestedModel ?? result.model,
+      );
+      const servedModelName = withProviderPrefix(args.model, result.model);
 
-  if (result.finishReason === "tool-calls") {
-    // tool-call step을 즉시 기록하고, 다음 follow-up이 같은 row에 결과를 채운다.
-    const toolCalls = result.content.filter((c) => c.type === "tool-call");
-    for (let i = 0; i < toolCalls.length; i++) {
-      const tc = toolCalls[i]!;
-      if (tc.type !== "tool-call") continue;
+      // generate step 기록
       await RequestLogModel.appendStep(requestLogId, {
         step_index: stepIndex,
-        type: "tool_call",
-        tool_call_index: imageParts.length + i,
-        tool_call_id: tc.toolCallId,
-        tool_name: tc.toolName,
-        tool_args: tc.input,
+        type: "generate",
+        model_name: servedModelName,
+        requested_model_name: requestedModelName,
+        fallback_count: result.modelFallbacks?.length ?? 0,
+        input_tokens: result.usage.input_tokens,
+        output_tokens: result.usage.output_tokens,
+        cache_read_tokens: result.usage.cache_read_input_tokens,
+        cache_creation_tokens: result.usage.cache_creation_input_tokens,
+        cache_creation_5m_tokens: result.usage.cache_creation_5m_input_tokens,
+        cache_creation_1h_tokens: result.usage.cache_creation_1h_input_tokens,
+        cost_usd: Math.round(result.costUsd * 1_000_000),
+        cost_source: result.costSource,
+        duration_ms: result.durationMs,
+        ttft_ms: result.ttftMs,
+        finish_reason: result.finishReason,
       });
-    }
 
-    return { runContext: { requestLogId } };
-  }
+      const imageParts = getImageParts(result);
+      const imageCostMicroUsd = estimateImageGenerationCostMicroUsd(
+        result,
+        args.imageGenerationOptions,
+      );
+      for (const step of buildImageGenerationToolSteps(args, imageParts, stepIndex)) {
+        await RequestLogModel.appendStep(requestLogId, step);
+      }
 
-  // finishReason === "stop" → run 종료 (전체 step usage 합산)
-  const agg = await RequestLogModel.aggregateStepUsage(requestLogId);
-  await RequestLogModel.finishRun(requestLogId, {
-    status: "succeeded",
-    response: formatResponseForLog(result),
-    token_name: result.tokenName,
-    input_tokens: agg.input_tokens,
-    output_tokens: agg.output_tokens,
-    cache_read_tokens: agg.cache_read_tokens,
-    cache_creation_tokens: agg.cache_creation_tokens,
-    cache_creation_5m_tokens: agg.cache_creation_5m_tokens,
-    cache_creation_1h_tokens: agg.cache_creation_1h_tokens,
-    duration_ms: agg.duration_ms,
-    // multi-step run 부모의 모델은 최종 turn을 서빙한 모델이다.
-    requested_model_name: requestedModelName,
-    model_name: servedModelName,
-    fallback_count: agg.fallback_count,
-    cost_usd: agg.cost_usd,
-    cost_source: agg.cost_source,
-    image_cost_usd: imageCostMicroUsd,
-    image_cost_method:
-      imageCostMicroUsd !== null ? imageGenerationCostMethod(args.imageGenerationOptions) : null,
-    history: filterHistoryForStorage(args.history),
-  });
+      if (result.finishReason === "tool-calls") {
+        // tool-call step을 즉시 기록하고, 다음 follow-up이 같은 row에 결과를 채운다.
+        const toolCalls = result.content.filter((c) => c.type === "tool-call");
+        for (let i = 0; i < toolCalls.length; i++) {
+          const tc = toolCalls[i]!;
+          if (tc.type !== "tool-call") continue;
+          await RequestLogModel.appendStep(requestLogId, {
+            step_index: stepIndex,
+            type: "tool_call",
+            tool_call_index: imageParts.length + i,
+            tool_call_id: tc.toolCallId,
+            tool_name: tc.toolName,
+            tool_args: tc.input,
+          });
+        }
+
+        return { runContext: { requestLogId } };
+      }
+
+      // finishReason === "stop" → run 종료 (전체 step usage 합산)
+      const agg = await RequestLogModel.aggregateStepUsage(requestLogId);
+      await RequestLogModel.finishRun(requestLogId, {
+        status: "succeeded",
+        response: formatResponseForLog(result),
+        token_name: result.tokenName,
+        input_tokens: agg.input_tokens,
+        output_tokens: agg.output_tokens,
+        cache_read_tokens: agg.cache_read_tokens,
+        cache_creation_tokens: agg.cache_creation_tokens,
+        cache_creation_5m_tokens: agg.cache_creation_5m_tokens,
+        cache_creation_1h_tokens: agg.cache_creation_1h_tokens,
+        duration_ms: agg.duration_ms,
+        // multi-step run 부모의 모델은 최종 turn을 서빙한 모델이다.
+        requested_model_name: requestedModelName,
+        model_name: servedModelName,
+        fallback_count: agg.fallback_count,
+        cost_usd: agg.cost_usd,
+        cost_source: agg.cost_source,
+        image_cost_usd: imageCostMicroUsd,
+        image_cost_method:
+          imageCostMicroUsd !== null
+            ? imageGenerationCostMethod(args.imageGenerationOptions)
+            : null,
+        history: filterHistoryForStorage(args.history),
+      });
 
-  return {};
+      return {};
+    } finally {
+      releaseNativeRun(requestLogId);
+    }
+  });
 }
 
 export async function finishRunWithError(
@@ -185,11 +245,48 @@ export async function finishRunWithError(
   errorMessage: string,
   args?: QueryInput,
 ): Promise<void> {
-  await finishTerminalRun(requestLogId, "error", errorMessage, args);
+  if (interruptedNativeRunIds.has(requestLogId)) return;
+  return trackNativeFinalizer(requestLogId, async () => {
+    try {
+      await finishTerminalRun(requestLogId, "error", errorMessage, args);
+    } finally {
+      releaseNativeRun(requestLogId);
+    }
+  });
 }
 
 export async function finishRunAborted(requestLogId: number, args?: QueryInput): Promise<void> {
-  await finishTerminalRun(requestLogId, "aborted", "client disconnected", args);
+  if (interruptedNativeRunIds.has(requestLogId)) return;
+  return trackNativeFinalizer(requestLogId, async () => {
+    try {
+      await finishTerminalRun(requestLogId, "aborted", "client disconnected", args);
+    } finally {
+      releaseNativeRun(requestLogId);
+    }
+  });
+}
+
+/** 현재 이 프로세스가 provider를 실행 중인 native run만 재시작 오류로 마감한다. */
+export async function finishActiveNativeRunsForRestart(): Promise<void> {
+  const requestLogIds = [...activeNativeRunRefs.keys()];
+  for (const requestLogId of requestLogIds) {
+    interruptedNativeRunIds.add(requestLogId);
+    activeNativeRunRefs.delete(requestLogId);
+  }
+
+  await Promise.all(
+    requestLogIds.map(async (requestLogId) => {
+      await Promise.all(activeNativeFinalizers.get(requestLogId) ?? []);
+      await finishTerminalRun(requestLogId, "error", "server restarted");
+    }),
+  );
+}
+
+/** 프로세스 전역 registry를 격리해야 하는 단위 테스트 전용. */
+export function resetNativeRunRegistryForTests(): void {
+  activeNativeRunRefs.clear();
+  interruptedNativeRunIds.clear();
+  activeNativeFinalizers.clear();
 }
 
 async function finishTerminalRun(