Skip to content
Python
7.9 KB
Raw Blame
import type {
  MemoryProcessingSummary,
  SourceResponse,
} from "@one-memory/contracts";
import { expect, it } from "vitest";
import {
  type MemoryArrival,
  type MemoryArrivalPhase,
  memoryArrivalTitle,
  resolveMemoryArrival,
} from "./memory-arrival-state";

const processing: MemoryProcessingSummary = {
  pending: 0,
  fresh_pending: 0,
  backlog_pending: 0,
  outside_window_pending: 0,
  recent_completions: [],
  running: 0,
  waiting_for_model: 0,
  completed: 0,
  failed: 0,
  blocked_stages: [],
  seconds_per_completion: null,
  extraction_window_preset: "all",
  manual_extract_batches_planned: 0,
  manual_extract_batches_current: 0,
  active_queue: 0,
  in_flight_count: 0,
};
const sources = [
  { authorized: true, imported_messages: 12, imported_conversations: 3 },
  { authorized: false, imported_messages: 100, imported_conversations: 10 },
] as SourceResponse[];
const base = { processing, sources, loaded: true };

it("uses the parent's setup snapshot, not empty task counts or fallback totals", () => {
  const arrival: MemoryArrival = {
    importing: true,
    importedMessages: 29155,
    importedConversations: 400,
    phase: "model-required",
  };
  expect(resolveMemoryArrival({ ...base, arrival })).toBe(arrival);
});

it("does not infer missing setup or running from an empty or queued task summary", () => {
  expect(resolveMemoryArrival(base)).toEqual({
    importing: false,
    importedMessages: 12,
    importedConversations: 3,
    phase: "idle",
  });
  expect(
    resolveMemoryArrival({ ...base, processing: { ...processing, pending: 9 } })
      .phase,
  ).toBe("idle");
});

it.each([
  ["running", { running: 1 }, "processing"],
  ["model count", { waiting_for_model: 1 }, "model-required"],
  [
    "model block",
    {
      blocked_stages: [
        { kind: "extract", reason: "model_profile_not_active", count: 1 },
      ],
    },
    "model-required",
  ],
  ["failure", { failed: 1 }, "failed"],
  [
    "unknown block",
    { blocked_stages: [{ kind: "extract", reason: "unknown", count: 1 }] },
    "idle",
  ],
  [
    "zero count block",
    {
      blocked_stages: [
        { kind: "extract", reason: "model_profile_not_active", count: 0 },
      ],
    },
    "idle",
  ],
] as [string, Partial<MemoryProcessingSummary>, MemoryArrivalPhase][])(
  "fallback classifies only positive known signals: %s",
  (_name, change, phase) => {
    expect(
      resolveMemoryArrival({
        ...base,
        processing: {
          ...processing,
          ...change,
          blocked_stages: [...(change.blocked_stages ?? [])],
        },
      }).phase,
    ).toBe(phase);
  },
);

it("does not claim processing before the snapshot is loaded", () => {
  expect(resolveMemoryArrival({ ...base, loaded: false }).phase).toBe(
    "checking",
  );
  expect(resolveMemoryArrival({ ...base, processing: null }).phase).toBe(
    "checking",
  );
  expect(
    resolveMemoryArrival({ ...base, sources: [], processing: null }).phase,
  ).toBe("idle");
});

it("does not promise continued processing for stale or queued-only state", () => {
  const idle = resolveMemoryArrival({
    ...base,
    processing: { ...processing, pending: 50 },
  });
  expect(memoryArrivalTitle(idle)).not.toContain("正在");
  expect(memoryArrivalTitle({ ...idle, phase: "checking" })).toBe("进度待更新");
  expect(
    memoryArrivalTitle({ ...idle, phase: "checking", refreshing: true }),
  ).toBe("已保存内容保留,正在核对进度");
});

it.each([
  ["model_profile_not_active", "model-required"],
  ["hy_memory_model_authentication_failed", "model-required"],
  ["hy_memory_model_payment_required", "model-required"],
] as const)(
  "keeps a parent-confirmed %s blocker actionable even when old running counts remain",
  (reason, phase) => {
    expect(
      resolveMemoryArrival({
        ...base,
        arrival: {
          importing: true,
          importedMessages: 12,
          importedConversations: 3,
          phase,
        },
        processing: {
          ...processing,
          running: 1,
          blocked_stages: [{ kind: "extract", reason, count: 1 }],
        },
      }).phase,
    ).toBe(phase);
  },
);

it("keeps recoverable failures in details while confirmed processing continues", () => {
  const blocks = [
    { kind: "extract", reason: "hy_memory_input_exceeds_window", count: 4 },
  ];
  const result = resolveMemoryArrival({
    ...base,
    processing: {
      ...processing,
      running: 1,
      failed: 4,
      backlog_pending: 12,
      blocked_stages: blocks,
    },
  });
  expect(result.phase).toBe("processing");
  expect(result.blockedStages).toEqual(blocks);
  expect(result.backlogPending).toBe(12);
  expect(memoryArrivalTitle(result)).toBe("正在沉淀记忆");
});

it("does not ask anyone to look at a failure Core is already retrying", () => {
  const blocks = [
    {
      kind: "extract",
      reason: "hy_memory_write_verification_clause_incomplete",
      count: 1,
    },
    {
      kind: "extract",
      reason: "hy_memory_write_verification_failed",
      count: 1,
    },
  ];
  const result = resolveMemoryArrival({
    ...base,
    processing: { ...processing, failed: 2, blocked_stages: blocks },
  });

  // "failed" shows "请先核对失败原因,再决定是否重试" and a repair button.
  // "idle" does not, and with memories already on screen the arrival panel
  // takes itself off the page entirely.
  expect(result.phase).toBe("idle");
  // Still on hand: the counts are real, they are just nobody's job.
  expect(result.blockedStages).toEqual(blocks);
});

it.each([0, 134])(
  "active import with failures and %i queued tasks is not active generation",
  (pending) => {
    const blocks = [
      { kind: "extract", reason: "hy_memory_model_request_failed", count: 1 },
      { kind: "extract", reason: "hy_memory_input_exceeds_window", count: 5 },
    ];
    const result = resolveMemoryArrival({
      ...base,
      arrival: {
        importing: true,
        importedMessages: 7865,
        importedConversations: 30,
        phase: "importing",
        memoryCount: 0,
      },
      processing: { ...processing, failed: 6, pending, blocked_stages: blocks },
    });
    expect(result.phase).toBe("failed");
    expect(result.importing).toBe(true);
    expect(result.memoryCount).toBe(0);
    expect(result.blockedStages).toEqual(blocks);
    expect(memoryArrivalTitle(result)).toBe("待继续");
  },
);

it.each([
  "hy_memory_model_request_failed",
  "hy_memory_model_rate_limited",
  "hy_memory_input_exceeds_window",
  "hy_memory_model_authentication_failed",
])("a historical %s does not hide another confirmed running task", (reason) => {
  const result = resolveMemoryArrival({
    ...base,
    arrival: {
      importing: true,
      importedMessages: 7865,
      importedConversations: 30,
      phase: "failed",
    },
    processing: {
      ...processing,
      running: 1,
      failed: 6,
      pending: 134,
      waiting_for_model: 1,
      blocked_stages: [{ kind: "extract", reason, count: 1 }],
    },
  });
  expect(result.phase).toBe("processing");
  expect(result.blockedStages?.[0].reason).toBe(reason);
  expect(
    resolveMemoryArrival({ ...base, arrival: result, processing: null }).phase,
  ).toBe("processing");
});

it.each(["checking", "unavailable", "stopped", "model-required"] as const)(
  "explicit parent %s remains authoritative over a running count",
  (phase) => {
    expect(
      resolveMemoryArrival({
        ...base,
        arrival: {
          importing: true,
          importedMessages: 12,
          importedConversations: 3,
          phase,
        },
        processing: { ...processing, running: 1 },
      }).phase,
    ).toBe(phase);
  },
);

it("raw import alone has an import title, without a generated-memory promise", () => {
  const result = resolveMemoryArrival({
    ...base,
    arrival: {
      importing: true,
      importedMessages: 12,
      importedConversations: 3,
      phase: "importing",
    },
  });
  expect(result.phase).toBe("importing");
  expect(memoryArrivalTitle(result)).toBe("正在导入对话");
});