Spot it. Save it. Free, local-first Chrome extension for images, videos and prompts. Explore 2,000+ curated cases and connect your library to AI Agents via MCP. 提示词导演
JavaScript ai-artai-videochrome-extensionclaude-codecodexhiggsfieldjimenglocal-firstmcpmidjourneymoodboardprompt-engineeringprompt-libraryprompt-managerreference-libraryseedancevisual-bookmarksweb-clipper
import { sanitizeAnalysisDiagnostic } from "./analysis-response.js";
import { createAnalysisRequestBudget } from "./analysis-retry-policy.js";
export const ANALYSIS_TASK_PRIORITIES = Object.freeze(["interactive", "user_batch", "background_import"]);
export function normalizeAnalysisPriority(value) {
const priority = String(value ?? "").trim();
return ANALYSIS_TASK_PRIORITIES.includes(priority) ? priority : "user_batch";
}
export function analysisTaskPriorityRank(value) {
return {
interactive: 0,
user_batch: 1,
background_import: 2
}[normalizeAnalysisPriority(value)] ?? 1;
}
export function createAnalysisTask(value = {}) {
const now = timestamp(value.now);
return {
version: 1,
id: cleanId(value.id, "analysis-task"),
priority: normalizeAnalysisPriority(value.priority),
status: "queued",
executionState: "queued",
createdAt: now,
updatedAt: now,
activeAttemptId: "",
attemptCount: 0,
phase: "queued",
deadlineAt: "",
requestStartedAt: "",
providerMayHaveAccepted: false,
attempts: []
};
}
export function startAnalysisAttempt(value, options = {}) {
const task = normalizeAnalysisTask(value);
if (["canceled", "completed", "failed"].includes(task.status)) {
throw new Error("任务已经结束,不能再开始新的 Attempt");
}
if (task.status === "running") {
throw new Error("任务已经在运行中");
}
const attemptId = cleanId(options.attemptId, "attempt");
const now = timestamp(options.now);
const attemptNumber = task.attemptCount + 1;
const nextAttempt = {
id: attemptId,
attemptNumber,
status: "running",
startedAt: now,
finishedAt: "",
result: null,
writeCount: 0
};
task.attempts.push(nextAttempt);
task.activeAttemptId = attemptId;
task.attemptCount = attemptNumber;
task.status = "running";
task.executionState = "running";
task.phase = "queued";
task.deadlineAt = String(options.deadlineAt ?? "");
task.requestStartedAt = "";
task.providerMayHaveAccepted = false;
task.updatedAt = now;
return task;
}
export function updateAnalysisTaskProgress(value, options = {}) {
const task = normalizeAnalysisTask(value);
const attempt = requireActiveAttempt(task, options.attemptId);
if (options.requestBudget) attempt.requestBudget = normalizeRequestBudget(options.requestBudget);
if (options.requestId) attempt.requestId = String(options.requestId);
if (options.diagnostic) attempt.diagnostic = sanitizeAnalysisDiagnostic(options.diagnostic);
const now = timestamp(options.now);
task.phase = normalizeAnalysisPhase(options.phase, task.phase);
if (options.providerMayHaveAccepted === true) {
task.providerMayHaveAccepted = true;
task.requestStartedAt ||= now;
}
task.updatedAt = now;
return task;
}
export function restartRunningAnalysisTask(value, options = {}) {
const task = normalizeAnalysisTask(value);
if (task.status !== "running") return task;
const now = timestamp(options.now);
const attempt = currentAttempt(task);
const executionState = task.providerMayHaveAccepted ? "execution_state_unknown" : "canceled";
if (attempt) {
attempt.status = executionState;
attempt.finishedAt = now;
}
task.activeAttemptId = "";
task.status = "stopped";
task.executionState = executionState;
task.phase = "stopped";
task.updatedAt = now;
return task;
}
export function cancelQueuedAnalysisTask(value, options = {}) {
const task = normalizeAnalysisTask(value);
if (task.status !== "queued" || task.attempts.length) return task;
task.status = "canceled";
task.executionState = "canceled";
task.updatedAt = timestamp(options.now);
return task;
}
export function applyAnalysisAttemptWrite(value, write = {}) {
const task = normalizeAnalysisTask(value);
const attemptId = String(write.attemptId ?? "").trim();
const attempt = attemptId ? task.attempts.find((item) => item.id === attemptId) : null;
if (!attempt || task.activeAttemptId !== attemptId || task.status !== "running" || task.executionState !== "running" || attempt.status !== "running") {
throw staleAttemptError();
}
const now = timestamp(write.now);
if (Object.hasOwn(write, "result")) {
attempt.result = structuredClone(write.result);
}
attempt.writeCount += 1;
task.updatedAt = now;
return task;
}
export function completeAnalysisAttempt(value, options = {}) {
const task = applyAnalysisAttemptWrite(value, {
attemptId: options.attemptId,
result: options.result,
now: options.now
});
const attempt = currentAttempt(task);
attempt.status = "completed";
attempt.finishedAt = timestamp(options.now);
task.status = "completed";
task.executionState = "completed";
task.phase = "completed";
task.activeAttemptId = "";
task.updatedAt = attempt.finishedAt;
return task;
}
export function failAnalysisAttempt(value, options = {}) {
const task = normalizeAnalysisTask(value);
const attempt = requireActiveAttempt(task, options.attemptId);
const now = timestamp(options.now);
attempt.status = "failed";
attempt.finishedAt = now;
attempt.error = String(options.error ?? "").trim();
if (options.diagnostic) attempt.diagnostic = sanitizeAnalysisDiagnostic(options.diagnostic);
if (options.requestBudget) attempt.requestBudget = normalizeRequestBudget(options.requestBudget);
task.status = "failed";
task.executionState = "failed";
task.phase = "failed";
task.activeAttemptId = "";
task.updatedAt = now;
return task;
}
export function retryAnalysisAttempt(value, options = {}) {
const task = normalizeAnalysisTask(value);
if (options.confirmed !== true) throw new Error("重新发起分析前必须确认可能再次计费");
if (!["failed", "stopped"].includes(task.status) && task.executionState !== "execution_state_unknown") {
throw new Error("当前分析任务不能重新发起");
}
task.status = "queued";
task.executionState = "queued";
task.phase = "queued";
task.deadlineAt = "";
task.requestStartedAt = "";
task.activeAttemptId = "";
task.providerMayHaveAccepted = false;
return startAnalysisAttempt(task, options);
}
export function stopAnalysisTask(value, options = {}) {
const task = normalizeAnalysisTask(value);
if (["completed", "failed", "canceled"].includes(task.status)) return task;
const now = timestamp(options.now);
const attempt = currentAttempt(task);
if (attempt?.status === "running") {
attempt.status = "canceled";
attempt.finishedAt = now;
}
task.status = "stopped";
task.executionState = "canceled";
task.phase = "stopped";
task.activeAttemptId = "";
task.updatedAt = now;
return task;
}
export function normalizeAnalysisTask(value) {
if (!value || typeof value !== "object" || Array.isArray(value)) {
return createAnalysisTask();
}
const task = structuredClone(value);
task.version = 1;
task.id = cleanId(task.id, "analysis-task");
task.priority = normalizeAnalysisPriority(task.priority);
task.status = normalizeTaskStatus(task.status);
task.executionState = normalizeExecutionState(task.executionState, task.status);
task.createdAt = String(task.createdAt ?? "");
task.updatedAt = String(task.updatedAt ?? task.createdAt ?? "");
task.activeAttemptId = String(task.activeAttemptId ?? "");
task.attemptCount = Math.max(0, Math.floor(Number(task.attemptCount) || 0));
task.phase = normalizeAnalysisPhase(task.phase, task.status === "running" ? "queued" : task.status);
task.deadlineAt = String(task.deadlineAt ?? "");
task.requestStartedAt = String(task.requestStartedAt ?? "");
task.providerMayHaveAccepted = task.providerMayHaveAccepted === true;
task.attempts = Array.isArray(task.attempts)
? task.attempts.flatMap((attempt) => normalizeAttempt(attempt))
: [];
if (!task.attemptCount) task.attemptCount = task.attempts.reduce((max, attempt) => Math.max(max, attempt.attemptNumber), 0);
const activeAttempt = task.activeAttemptId ? task.attempts.find((attempt) => attempt.id === task.activeAttemptId) : null;
if (task.status === "running" && (!activeAttempt || activeAttempt.status !== "running")) {
task.status = "stopped";
task.executionState = "execution_state_unknown";
task.activeAttemptId = "";
}
if (task.status !== "running" && task.executionState === "running") {
task.executionState = task.status === "queued" ? "queued" : task.status === "canceled" ? "canceled" : task.status === "completed" ? "completed" : "execution_state_unknown";
}
return task;
}
function normalizeAttempt(value) {
if (!value || typeof value !== "object" || Array.isArray(value)) return [];
const id = cleanId(value.id, "attempt");
const attemptNumber = Math.max(1, Math.floor(Number(value.attemptNumber) || 0));
const status = normalizeAttemptStatus(value.status);
return [{
id,
attemptNumber,
status,
startedAt: String(value.startedAt ?? ""),
finishedAt: String(value.finishedAt ?? ""),
result: Object.hasOwn(value, "result") ? structuredClone(value.result) : null,
error: String(value.error ?? ""),
diagnostic: value.diagnostic ? sanitizeAnalysisDiagnostic(value.diagnostic) : null,
requestBudget: normalizeRequestBudget(value.requestBudget),
requestId: String(value.requestId ?? ""),
writeCount: Math.max(0, Math.floor(Number(value.writeCount) || 0))
}];
}
function normalizeRequestBudget(value = {}) {
const budget = createAnalysisRequestBudget();
budget.providerCalls = Math.max(0, Math.floor(Number(value.providerCalls) || 0));
budget.outputCorrectionRequests = Math.max(0, Math.floor(Number(value.outputCorrectionRequests) || 0));
return budget;
}
function normalizeTaskStatus(value) {
const status = String(value ?? "").trim();
return ["queued", "running", "stopped", "completed", "failed", "canceled"].includes(status) ? status : "queued";
}
function normalizeExecutionState(value, status) {
const state = String(value ?? "").trim();
if (["queued", "running", "execution_state_unknown", "completed", "failed", "canceled"].includes(state)) return state;
return status === "running" ? "running"
: status === "canceled" ? "canceled"
: status === "completed" ? "completed"
: status === "failed" ? "failed"
: status === "stopped" ? "execution_state_unknown"
: "queued";
}
function normalizeAttemptStatus(value) {
const status = String(value ?? "").trim();
return ["queued", "running", "execution_state_unknown", "completed", "failed", "canceled"].includes(status)
? status
: "queued";
}
function normalizeAnalysisPhase(value, fallback = "queued") {
const phase = String(value ?? "").trim();
return ["queued", "encoding", "uploading", "processing", "analyzing", "retrying", "correcting", "completed", "failed", "stopped"].includes(phase)
? phase
: String(fallback ?? "queued").trim() || "queued";
}
function currentAttempt(task) {
return task.activeAttemptId ? task.attempts.find((attempt) => attempt.id === task.activeAttemptId) ?? null : null;
}
function requireActiveAttempt(task, attemptIdValue) {
const attemptId = String(attemptIdValue ?? "").trim();
const attempt = currentAttempt(task);
if (!attempt || attempt.id !== attemptId || task.status !== "running" || task.executionState !== "running" || attempt.status !== "running") {
throw staleAttemptError();
}
return attempt;
}
function staleAttemptError() {
const error = new Error("这次写回已经失效,请重新发起新的 Attempt");
error.code = "STALE_ATTEMPT";
return error;
}
function cleanId(value, fallbackPrefix) {
const text = String(value ?? "").trim();
return text || `${fallbackPrefix}:${globalThis.crypto.randomUUID()}`;
}
function timestamp(value) {
return String(value ?? new Date().toISOString());
}