Genarrative/src/services/image-editor/editorAgentClient.ts

import type {
  CreateEditorAgentConversationRequest,
  EditorAgentConversationDetail,
  EditorAgentConversationListResponse,
  EditorAgentConversationResponse,
  EditorAgentConversationSummary,
  EditorAgentMessageRequest,
  EditorAgentMessageResponse,
} from '../../../packages/shared/src/contracts/editorAgent';
import { requestJson } from '../apiClient';

const EDITOR_PROJECT_AGENT_CONVERSATION_API_BASE = '/api/editor/projects';
const EDITOR_AGENT_CONVERSATION_API_BASE = '/api/editor/agent-conversations';
const EDITOR_AGENT_MESSAGE_TIMEOUT_MS = 1_200_000;
const EDITOR_AGENT_MESSAGE_RETRY = {
  maxRetries: 1,
  baseDelayMs: 250,
  maxDelayMs: 250,
  retryUnsafeMethods: true,
} as const;

export type SendEditorAgentMessageOptions = {
  signal?: AbortSignal;
};

type DeleteEditorAgentConversationResponse = {
  deletedConversationId: string;
  conversation: EditorAgentConversationSummary;
};

function jsonRequest(method: 'POST', body: Record<string, unknown>) {
  return {
    method,
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(body),
  };
}

function projectAgentConversationsPath(projectId: string) {
  return `${EDITOR_PROJECT_AGENT_CONVERSATION_API_BASE}/${encodeURIComponent(
    projectId,
  )}/agent-conversations`;
}

function agentConversationPath(conversationId: string) {
  return `${EDITOR_AGENT_CONVERSATION_API_BASE}/${encodeURIComponent(
    conversationId,
  )}`;
}

function agentToolCallActionPath(
  conversationId: string,
  messageId: number,
  action: 'confirm' | 'cancel',
) {
  return `${agentConversationPath(conversationId)}/messages/${encodeURIComponent(
    String(messageId),
  )}/${action}`;
}

export async function listEditorAgentConversations(
  projectId: string,
): Promise<EditorAgentConversationSummary[]> {
  const response = await requestJson<EditorAgentConversationListResponse>(
    projectAgentConversationsPath(projectId),
    { method: 'GET' },
    '读取画布 Agent 会话列表失败',
  );
  return response.conversations;
}

export async function createEditorAgentConversation(
  projectId: string,
  input: CreateEditorAgentConversationRequest = {},
): Promise<EditorAgentConversationDetail> {
  const body: Record<string, unknown> = {};
  if (input.title !== undefined) {
    body.title = input.title;
  }
  const response = await requestJson<EditorAgentConversationResponse>(
    projectAgentConversationsPath(projectId),
    jsonRequest('POST', body),
    '创建画布 Agent 会话失败',
  );
  return response.conversation;
}

export async function getEditorAgentConversation(
  conversationId: string,
): Promise<EditorAgentConversationDetail> {
  const response = await requestJson<EditorAgentConversationResponse>(
    agentConversationPath(conversationId),
    { method: 'GET' },
    '读取画布 Agent 会话失败',
  );
  return response.conversation;
}

export async function deleteEditorAgentConversation(
  conversationId: string,
): Promise<EditorAgentConversationSummary> {
  const response = await requestJson<DeleteEditorAgentConversationResponse>(
    agentConversationPath(conversationId),
    { method: 'DELETE' },
    '删除画布 Agent 会话失败',
  );
  return response.conversation;
}

export async function sendEditorAgentMessage(
  conversationId: string,
  payload: EditorAgentMessageRequest,
  options: SendEditorAgentMessageOptions = {},
): Promise<EditorAgentMessageResponse> {
  return requestJson<EditorAgentMessageResponse>(
    `${agentConversationPath(conversationId)}/messages`,
    {
      ...jsonRequest('POST', payload as unknown as Record<string, unknown>),
      signal: options.signal,
    },
    '发送画布 Agent 消息失败',
    {
      timeoutMs: EDITOR_AGENT_MESSAGE_TIMEOUT_MS,
      authImpact: 'local',
      retry: EDITOR_AGENT_MESSAGE_RETRY,
    },
  );
}

export async function confirmEditorAgentToolCall(
  conversationId: string,
  messageId: number,
): Promise<void> {
  await requestJson<unknown>(
    agentToolCallActionPath(conversationId, messageId, 'confirm'),
    { method: 'POST' },
    '确认画布 Agent 操作失败',
    {
      timeoutMs: EDITOR_AGENT_MESSAGE_TIMEOUT_MS,
      authImpact: 'local',
    },
  );
}

export async function cancelEditorAgentToolCall(
  conversationId: string,
  messageId: number,
): Promise<void> {
  await requestJson<unknown>(
    agentToolCallActionPath(conversationId, messageId, 'cancel'),
    { method: 'POST' },
    '取消画布 Agent 操作失败',
    { authImpact: 'local' },
  );
}