Skip to content

Your lightweight open-source personal agent.

52.2 KB
Raw Blame
import { isContextGraph, isContextInspection } from "@/lib/context-graph";
import { isCompactionPhase, isCompactionReason } from "../../../packages/client-events/notifications";
import type {
  ApiServicePayload,
  AutomationChatsPayload,
  AutomationChatUpdate,
  AutomationsPayload,
  AutomaticModelAPIPayload,
  AutomationUpdatePayload,
  ChannelConfigurePayload,
  ChannelConnectPayload,
  ChannelValidationPayload,
  ChatSummary,
  ContextGraph,
  CliAppsPayload,
  FilePreviewPayload,
  FileReferenceMetadata,
  ImageGenerationSettingsUpdate,
  McpPresetsPayload,
  McpOAuthFlowPayload,
  MarketplaceProvider,
  NanobotFeaturesPayload,
  ModelConfigurationCreate,
  ModelConfigurationUpdate,
  NetworkSafetySettingsUpdate,
  PairingPayload,
  PromptIndex,
  ProviderCreationUpdate,
  ProviderModelsPayload,
  ProviderOAuthCompletionResult,
  ProviderOAuthLoginResult,
  ProviderSettingsUpdate,
  RecoveryState,
  SessionDeleteResult,
  SessionHandle,
  SessionAutomationsPayload,
  SettingsPayload,
  SidebarStatePayload,
  SkillDetail,
  SkillActionPayload,
  SkillInstallPayload,
  SkillsPayload,
  SkillsSearchPayload,
  SkillsTrendsPayload,
  SkillsTrendingPayload,
  SlashCommand,
  SlashCommandLifecycle,
  SubagentTaskSnapshot,
  SubagentTasksPayload,
  TranscriptionSettingsUpdate,
  ThreadProjectionEvent,
  WebSearchSettingsUpdate,
  WorkspacesPayload,
  WorkspaceDirectoriesPayload,
  WebuiThreadPersistedPayload,
  WebuiThreadTraceDetailPayload,
  WorkspaceScopePayload,
} from "./types";
import { fetchWithTimeout } from "./http";
import { isSubagentTask } from "./subagent-tasks";

const API_READ_TIMEOUT_MS = 20_000;
const API_MUTATION_TIMEOUT_MS = 20_000;
const PACKAGE_MUTATION_TIMEOUT_MS = 150_000;
const SLASH_COMMAND_LIFECYCLES = new Set<SlashCommandLifecycle>([
  "side_channel",
  "finalize_active_turn",
  "stop_active_turn",
  "agent_turn",
  "agent_turn_with_args",
]);

function isSlashCommandLifecycle(value: unknown): value is SlashCommandLifecycle {
  return (
    typeof value === "string"
    && SLASH_COMMAND_LIFECYCLES.has(value as SlashCommandLifecycle)
  );
}
export class ApiError extends Error {
  status: number;
  constructor(status: number, message: string) {
    super(message);
    this.status = status;
    this.name = "ApiError";
  }
}

export interface WebUIMutationTransport {
  requestMutation<T>(
    action: string,
    payload?: Record<string, unknown>,
    timeoutMs?: number,
  ): Promise<T>;
}

async function request<T>(
  url: string,
  token: string,
  init?: RequestInit,
  timeoutMs: number = 0,
): Promise<T> {
  const res = await fetchWithTimeout(
    url,
    {
      ...(init ?? {}),
      headers: {
        ...(init?.headers ?? {}),
        Authorization: `Bearer ${token}`,
      },
      credentials: "same-origin",
    },
    timeoutMs,
  );
  if (!res.ok) {
    const text = typeof res.text === "function" ? (await res.text()).trim() : "";
    let message = text;
    if (text.startsWith("{")) {
      try {
        const payload: unknown = JSON.parse(text);
        if (payload && typeof payload === "object") {
          const error = (payload as { error?: unknown }).error;
          if (typeof error === "string" && error.trim()) message = error.trim();
        }
      } catch {
        // Preserve non-JSON error bodies exactly as returned by the gateway.
      }
    }
    throw new ApiError(res.status, message || `HTTP ${res.status}`);
  }
  const contentType = res.headers?.get?.("content-type") ?? "";
  if (contentType && !contentType.toLowerCase().includes("application/json")) {
    const text = typeof res.text === "function" ? await res.text() : "";
    const isHtml = text.trimStart().toLowerCase().startsWith("<!doctype");
    throw new ApiError(
      res.status,
      isHtml
        ? "Gateway returned WebUI HTML instead of JSON. Restart nanobot gateway and try again."
        : "Gateway returned a non-JSON response.",
    );
  }
  return (await res.json()) as T;
}

async function mutation<T>(
  transport: WebUIMutationTransport,
  action: string,
  payload: Record<string, unknown> = {},
  timeoutMs: number = API_MUTATION_TIMEOUT_MS,
): Promise<T> {
  try {
    return await transport.requestMutation<T>(action, payload, timeoutMs);
  } catch (reason) {
    const status = (
      typeof reason === "object"
      && reason !== null
      && "status" in reason
      && typeof reason.status === "number"
    ) ? reason.status : 500;
    const message = reason instanceof Error ? reason.message : "WebUI mutation failed";
    throw new ApiError(status, message);
  }
}

function compactMcpValues(values: Record<string, unknown>): Record<string, unknown> {
  const payload: Record<string, unknown> = {};
  Object.entries(values).forEach(([key, value]) => {
    if (value === null || value === undefined) return;
    if (typeof value === "string") {
      const trimmed = value.trim();
      if (trimmed) payload[key] = trimmed;
      return;
    }
    payload[key] = value;
  });
  return payload;
}

function splitKey(key: string): { channel: string; chatId: string } {
  const idx = key.indexOf(":");
  if (idx === -1) return { channel: "", chatId: key };
  return { channel: key.slice(0, idx), chatId: key.slice(idx + 1) };
}

function normalizeSessionHandle(value: unknown): SessionHandle | null {
  if (!value || typeof value !== "object") return null;
  const handle = value as Partial<SessionHandle>;
  const id = typeof handle.id === "string" ? handle.id.trim() : "";
  const name = typeof handle.name === "string" ? handle.name.trim() : "";
  if (
    !/^handle_[a-f0-9]{32}$/i.test(id)
    || !name
    || !/^[\p{L}\p{N}_-]+$/u.test(name)
  ) return null;
  return { id, name };
}

export async function listSessions(
  token: string,
  base: string = "",
): Promise<ChatSummary[]> {
  type Row = {
    key: string;
    created_at: string | null;
    updated_at: string | null;
    title?: string;
    preview?: string;
    model_preset?: string | null;
    run_started_at?: number | null;
    recovery_state?: RecoveryState | null;
    workspace_scope?: WorkspaceScopePayload | null;
    project_locked?: boolean;
    handle?: SessionHandle | null;
  };
  const body = await request<{ sessions: Row[] }>(
    `${base}/api/sessions`,
    token,
    undefined,
    API_READ_TIMEOUT_MS,
  );
  return body.sessions.map((s) => {
    const handle = normalizeSessionHandle(s.handle);
    return {
      key: s.key,
      ...splitKey(s.key),
      createdAt: s.created_at,
      updatedAt: s.updated_at,
      title: s.title ?? "",
      preview: s.preview ?? "",
      modelPreset: s.model_preset ?? null,
      runStartedAt: s.run_started_at ?? null,
      recoveryState: s.recovery_state ?? null,
      workspaceScope: s.workspace_scope ?? null,
      projectLocked: s.project_locked ?? true,
      handle,
    };
  });
}

/** Disk-backed WebUI display thread snapshot (separate from agent session). */
export interface FetchWebuiThreadOptions {
  limit?: number;
  direction?: "latest";
  before?: string | null;
  after?: string | null;
  signal?: AbortSignal;
  revision?: string;
  cached?: WebuiThreadPersistedPayload;
}

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === "object" && value !== null && !Array.isArray(value);
}

function isRecordArray(value: unknown): value is Array<Record<string, unknown>> {
  return Array.isArray(value) && value.every(isRecord);
}

function isProjectionMedia(value: unknown): boolean {
  return isRecord(value)
    && typeof value.url === "string"
    && (value.name === undefined || typeof value.name === "string")
    && (value.kind === undefined || ["image", "video", "file"].includes(String(value.kind)));
}

function hasStringField(value: Record<string, unknown>, field: string): boolean {
  return typeof value[field] === "string";
}

function isProjectionFileEdit(value: unknown): boolean {
  return isRecord(value)
    && hasStringField(value, "call_id")
    && hasStringField(value, "tool")
    && hasStringField(value, "path")
    && typeof value.added === "number"
    && typeof value.deleted === "number"
    && ["editing", "done", "error"].includes(String(value.status));
}

function hasValidProjectionMetadata(value: Record<string, unknown>): boolean {
  return (
    (value.projection_id === undefined || typeof value.projection_id === "string")
    && (value.created_at_ms === undefined || typeof value.created_at_ms === "number")
    && (value.turn_id === undefined || typeof value.turn_id === "string")
    && (value.turn_phase === undefined || [
      "user", "reasoning", "activity", "answer", "complete",
    ].includes(String(value.turn_phase)))
    && (value.turn_seq === undefined || typeof value.turn_seq === "number")
    && (
      value.response_sources === undefined
      || (isRecordArray(value.response_sources) && value.response_sources.every((source) => (
        typeof source.provider === "string" && source.provider.length > 0
        && typeof source.model === "string" && source.model.length > 0
        && typeof source.preset === "string" && source.preset.length > 0
        && (source.fallback === undefined || typeof source.fallback === "boolean")
      )))
    )
    && (
      value.source === undefined
      || (
        isRecord(value.source)
        && typeof value.source.kind === "string"
        && (value.source.label === undefined || typeof value.source.label === "string")
      )
    )
  );
}

function isProjectionTraceDetail(value: unknown): boolean {
  return isRecord(value)
    && typeof value.ref === "string"
    && /^\d{1,12}\.history-[0-9a-f]{20}$/.test(value.ref)
    && typeof value.bytes === "number"
    && Number.isFinite(value.bytes)
    && value.bytes >= 0
    && typeof value.traceCount === "number"
    && Number.isInteger(value.traceCount)
    && value.traceCount >= 0;
}

function parseThreadProjectionEvent(value: unknown, validatedGraphs: ReadonlySet<unknown> = new Set()): ThreadProjectionEvent {
  if (!isRecord(value) || typeof value.event !== "string" || typeof value.chat_id !== "string") {
    throw new Error("Invalid WebUI thread event");
  }
  if (!hasValidProjectionMetadata(value)
    || (value.stream_id !== undefined && typeof value.stream_id !== "string")
    || (value.projection_receipts !== undefined && (
      !Array.isArray(value.projection_receipts)
      || !value.projection_receipts.every((receipt: unknown) => isRecord(receipt)
        && typeof receipt.turn_id === "string" && receipt.turn_id.length > 0
        && Array.isArray(receipt.ranges)
        && receipt.ranges.every((range: unknown) => Array.isArray(range)
          && range.length === 2 && Number.isSafeInteger(range[0]) && range[0] >= 0
          && Number.isSafeInteger(range[1]) && range[1] >= range[0]))
    ))) {
    throw new Error("Invalid WebUI thread event metadata");
  }
  switch (value.event) {
    case "user_message":
      if (typeof value.text !== "string" || typeof value.starts_turn !== "boolean") break;
      if (value.media_urls !== undefined && (
        !Array.isArray(value.media_urls) || !value.media_urls.every(isProjectionMedia)
      )) break;
      if (value.cli_apps !== undefined && (
        !isRecordArray(value.cli_apps) || !value.cli_apps.every((item) => hasStringField(item, "name"))
      )) break;
      if (value.mcp_presets !== undefined && (
        !isRecordArray(value.mcp_presets)
        || !value.mcp_presets.every((item) => hasStringField(item, "name"))
      )) break;
      if (value.session_mentions !== undefined && (
        !isRecordArray(value.session_mentions)
        || !value.session_mentions.every((item) => (
          hasStringField(item, "name")
          && hasStringField(item, "session_key")
          && hasStringField(item, "title")
        ))
      )) break;
      if (value.provenance !== undefined && (
        !isRecord(value.provenance)
        || !isRecord(value.provenance.session_message)
        || !hasStringField(value.provenance.session_message, "message_id")
        || !isRecord(value.provenance.session_message.session)
      )) break;
      return value as unknown as ThreadProjectionEvent;
    case "message":
      if (typeof value.text !== "string") break;
      if (value.tool_events !== undefined && !isRecordArray(value.tool_events)) break;
      if (value.trace_detail !== undefined && (
        !["tool_hint", "progress"].includes(String(value.kind))
        || !isProjectionTraceDetail(value.trace_detail)
      )) break;
      if (value.media_urls !== undefined && (
        !Array.isArray(value.media_urls) || !value.media_urls.every(isProjectionMedia)
      )) break;
      return value as unknown as ThreadProjectionEvent;
    case "file_edit":
      if (!Array.isArray(value.edits) || !value.edits.every(isProjectionFileEdit)) break;
      return value as unknown as ThreadProjectionEvent;
    case "delta":
    case "reasoning_delta":
      if (typeof value.text !== "string") break;
      return value as unknown as ThreadProjectionEvent;
    case "stream_end":
    case "reasoning_end":
      if (value.text !== undefined && typeof value.text !== "string") break;
      return value as unknown as ThreadProjectionEvent;
    case "context_compaction":
      if (value.context_snapshot !== undefined && !isContextInspection(value.context_snapshot, (graph): graph is ContextGraph => validatedGraphs.has(graph) || isContextGraph(graph))) break;
      if (typeof value.compaction_id !== "string" || !value.compaction_id
        || !isCompactionPhase(value.phase)
        || (value.reason !== undefined && !isCompactionReason(value.reason))) break;
      return value as unknown as ThreadProjectionEvent;
    case "model_request": {
      if (value.context_graph !== undefined && !validatedGraphs.has(value.context_graph) && !isContextGraph(value.context_graph)) break;
      const isUsage = (usage: unknown) => isRecord(usage)
        && Object.values(usage).every((count) => typeof count === "number" && Number.isFinite(count) && count >= 0);
      if (typeof value.request_id !== "string" || !value.request_id
        || typeof value.run_id !== "string" || !value.run_id
        || !Number.isSafeInteger(value.sequence) || Number(value.sequence) < 0
        || !["started", "completed", "failed", "cancelled"].includes(String(value.phase))
        || (value.usage !== undefined && !isUsage(value.usage))
        || (value.request_usage != null && !isUsage(value.request_usage))
        || (value.round_usages !== undefined && (!Array.isArray(value.round_usages) || !value.round_usages.every(isUsage)))
        || (value.context_window_tokens !== undefined && (typeof value.context_window_tokens !== "number"
          || !Number.isFinite(value.context_window_tokens) || value.context_window_tokens < 0))) break;
      return value as unknown as ThreadProjectionEvent;
    }
    case "turn_end":
      return value as unknown as ThreadProjectionEvent;
  }
  throw new Error(`Invalid WebUI thread projection event: ${value.event}`);
}

export function parseWebuiThreadPayload(value: unknown): WebuiThreadPersistedPayload {
  if (!isRecord(value) || typeof value.schemaVersion !== "number") {
    throw new Error("Invalid WebUI thread response");
  }
  if (value.projection !== "events" || !Array.isArray(value.events)) {
    throw new Error("Invalid WebUI thread events");
  }
  const graphs = new Map<string, ContextGraph>();
  if (value.context_graphs !== undefined) {
    if (!isRecord(value.context_graphs)) throw new Error("Invalid context graph dictionary");
    const table = { nodes: value.context_graph_nodes, edges: value.context_graph_edges };
    if (!isContextGraph(table)) throw new Error("Invalid context graph entity table");
    const resolveIndex = <T,>(entries: readonly T[], index: unknown): T => {
      if (typeof index !== "number" || !Number.isSafeInteger(index) || index < 0 || index >= entries.length) {
        throw new Error("Unknown context graph entity reference");
      }
      return entries[index];
    };
    for (const [key, descriptor] of Object.entries(value.context_graphs)) {
      if (!isRecord(descriptor) || !Array.isArray(descriptor.nodes) || !Array.isArray(descriptor.edges)) {
        throw new Error("Invalid context graph dictionary entry");
      }
      const nodes = descriptor.nodes.map((index: unknown) => resolveIndex(table.nodes, index));
      const paths = new Set(nodes.map((node) => node.path));
      const edges = descriptor.edges.map((index: unknown) => {
        const edge = resolveIndex(table.edges, index);
        if (!paths.has(edge.source) || !paths.has(edge.target)) throw new Error("Invalid context graph edge reference");
        return edge;
      });
      graphs.set(key, { nodes, edges });
    }
  }
  const validatedGraphs = new Set(graphs.values());
  const resolveGraph = (key: unknown): ContextGraph => {
    const graph = typeof key === "string" ? graphs.get(key) : undefined;
    if (!graph) throw new Error("Unknown context graph reference");
    return graph;
  };
  const events = value.events.map((raw) => {
    if (!isRecord(raw)) return parseThreadProjectionEvent(raw);
    const event = { ...raw };
    if (event.context_graph_ref !== undefined) {
      if (event.context_graph !== undefined) throw new Error("Ambiguous context graph reference");
      event.context_graph = resolveGraph(event.context_graph_ref);
      delete event.context_graph_ref;
    }
    if (isRecord(event.context_snapshot) && event.context_snapshot.graph_ref !== undefined) {
      if (event.context_snapshot.graph !== undefined) throw new Error("Ambiguous context graph reference");
      const { graph_ref, ...snapshot } = event.context_snapshot;
      event.context_snapshot = { ...snapshot, graph: resolveGraph(graph_ref) };
    }
    return parseThreadProjectionEvent(event, validatedGraphs);
  });
  const body: Record<string, unknown> = { ...value, projection: "events", events };
  delete body.context_graphs;
  delete body.context_graph_nodes;
  delete body.context_graph_edges;
  return body as unknown as WebuiThreadPersistedPayload;
}

function parseWebuiThreadTraceDetailPayload(value: unknown): WebuiThreadTraceDetailPayload {
  if (
    !isRecord(value)
    || typeof value.message_id !== "string"
    || !/^history-[0-9a-f]{20}$/.test(value.message_id)
    || !Array.isArray(value.events)
  ) {
    throw new Error("Invalid WebUI thread trace detail response");
  }
  return {
    message_id: value.message_id,
    events: value.events.map((event) => parseThreadProjectionEvent(event)),
  };
}

export async function fetchWebuiThread(
  token: string,
  key: string,
  optionsOrBase?: FetchWebuiThreadOptions | string,
  base: string = "",
): Promise<WebuiThreadPersistedPayload | null> {
  const options = typeof optionsOrBase === "string" ? undefined : optionsOrBase;
  const resolvedBase = typeof optionsOrBase === "string" ? optionsOrBase : base;
  const params = new URLSearchParams();
  if (options?.limit !== undefined) params.set("limit", String(options.limit));
  if (options?.direction) params.set("direction", options.direction);
  if (options?.before) params.set("before", options.before);
  if (options?.after) params.set("after", options.after);
  params.set("include_model_requests", "1");
  params.set("context_graph_encoding", "references-v1");
  const query = params.toString();
  const suffix = query ? `?${query}` : "";
  const url = `${resolvedBase}/api/sessions/${encodeURIComponent(key)}/webui-thread${suffix}`;
  const headers: Record<string, string> = { Authorization: `Bearer ${token}` };
  if (options?.revision) headers["If-None-Match"] = `"${options.revision}"`;
  const res = await fetchWithTimeout(url, {
    headers,
    credentials: "same-origin",
    cache: "no-store",
    signal: options?.signal,
  });
  if (res.status === 304 && options?.cached) return options.cached;
  if (res.status === 404) return null;
  if (!res.ok) throw new ApiError(res.status, `HTTP ${res.status}`);
  return parseWebuiThreadPayload(await res.json());
}

export async function fetchPromptIndex(token: string, key: string, signal: AbortSignal, cached?: PromptIndex): Promise<PromptIndex> {
  const headers: Record<string, string> = { Authorization: `Bearer ${token}` };
  const query = cached?.revision ? `?since=${encodeURIComponent(cached.revision)}` : "";
  if (cached?.revision) headers["If-None-Match"] = `"${cached.revision}"`;
  const res = await fetchWithTimeout(`/api/sessions/${encodeURIComponent(key)}/webui-thread/prompts${query}`, {
    headers, credentials: "same-origin", cache: "no-store", signal,
  });
  if (res.status === 304 && cached) return cached;
  if (!res.ok) throw new ApiError(res.status, `HTTP ${res.status}`);
  const body: unknown = await res.json();
  if (!isRecord(body) || !Array.isArray(body.prompts)) throw new Error("Invalid prompt index");
  const replaceFrom = body.replaceFrom ?? 0;
  if (typeof replaceFrom !== "number" || !Number.isSafeInteger(replaceFrom)
    || replaceFrom < 0 || replaceFrom > (cached?.prompts.length ?? 0)
    || (body.revision != null && typeof body.revision !== "string")) throw new Error("Invalid prompt index revision");
  const prompts = body.prompts.map((item: unknown) => {
    if (!isRecord(item) || typeof item.id !== "string" || typeof item.preview !== "string"
      || typeof item.answerPreview !== "string" || typeof item.cursor !== "string" || typeof item.turnId !== "string"
      || typeof item.createdAt !== "number" || !Number.isFinite(item.createdAt)) {
      throw new Error("Invalid prompt summary");
    }
    return { id: item.id, preview: item.preview, answerPreview: item.answerPreview,
      cursor: item.cursor, createdAt: item.createdAt, turnId: item.turnId };
  });
  return { prompts: [...(cached?.prompts.slice(0, replaceFrom) ?? []), ...prompts],
    revision: typeof body.revision === "string" ? body.revision : undefined };
}

export async function fetchWebuiThreadTraceDetail(
  token: string,
  key: string,
  ref: string,
  base: string = "",
): Promise<WebuiThreadTraceDetailPayload> {
  const query = new URLSearchParams({ ref });
  const url = `${base}/api/sessions/${encodeURIComponent(key)}/webui-thread/trace-detail?${query}`;
  const res = await fetchWithTimeout(url, {
    headers: { Authorization: `Bearer ${token}` },
    credentials: "same-origin",
    cache: "no-store",
  });
  if (!res.ok) throw new ApiError(res.status, `HTTP ${res.status}`);
  return parseWebuiThreadTraceDetailPayload(await res.json());
}

export async function fetchFilePreview(
  token: string,
  key: string,
  path: string,
  base: string = "",
): Promise<FilePreviewPayload> {
  const query = new URLSearchParams();
  query.set("path", path);
  return request<FilePreviewPayload>(
    `${base}/api/sessions/${encodeURIComponent(key)}/file-preview?${query}`,
    token,
    { cache: "no-store" },
    API_READ_TIMEOUT_MS,
  );
}

export async function fetchFileReferenceMetadata(
  token: string,
  key: string,
  path: string,
): Promise<FileReferenceMetadata> {
  const query = new URLSearchParams({ path, metadata: "1" });
  return request<FileReferenceMetadata>(
    `/api/sessions/${encodeURIComponent(key)}/file-preview?${query}`,
    token,
    { cache: "no-store" },
    API_READ_TIMEOUT_MS,
  );
}

export async function fetchFilePreviewAvailability(
  token: string,
  key: string,
  path: string,
  base: string = "",
): Promise<boolean> {
  const query = new URLSearchParams();
  query.set("path", path);
  query.set("probe", "1");
  const payload = await request<{ available?: boolean }>(
    `${base}/api/sessions/${encodeURIComponent(key)}/file-preview?${query}`,
    token,
    { cache: "no-store" },
    API_READ_TIMEOUT_MS,
  );
  return payload.available !== false;
}

export async function fetchSessionAutomations(
  token: string,
  key: string,
  base: string = "",
): Promise<SessionAutomationsPayload> {
  return request<SessionAutomationsPayload>(
    `${base}/api/sessions/${encodeURIComponent(key)}/automations`,
    token,
    undefined,
    API_READ_TIMEOUT_MS,
  );
}

export async function fetchAutomations(
  token: string,
  base: string = "",
): Promise<AutomationsPayload> {
  return request<AutomationsPayload>(
    `${base}/api/webui/automations`,
    token,
    undefined,
    API_READ_TIMEOUT_MS,
  );
}

export async function fetchAutomationChats(token: string, id: string, signal?: AbortSignal): Promise<AutomationChatsPayload> {
  return request(`/api/webui/automations/chats?id=${encodeURIComponent(id)}`, token, { signal }, API_READ_TIMEOUT_MS);
}

export async function changeAutomationChat(transport: WebUIMutationTransport, id: string, values: AutomationChatUpdate): Promise<AutomationsPayload> {
  return mutation(transport, "automation.change_chat", { id, values });
}

export async function fetchAutomationRunResult(
  token: string,
  id: string,
  runAtMs: number,
  kind: "cron" | "local_trigger",
  signal?: AbortSignal,
): Promise<{ response: string | null }> {
  const query = new URLSearchParams({ id, run_at_ms: String(runAtMs), kind });
  return request<{ response: string | null }>(
    `/api/webui/automations/result?${query}`, token, { signal }, API_READ_TIMEOUT_MS,
  );
}

export async function runAutomationAction(
  transport: WebUIMutationTransport,
  action: "enable" | "disable" | "delete" | "run",
  id: string,
): Promise<AutomationsPayload> {
  return mutation<AutomationsPayload>(transport, `automation.${action}`, { id });
}

export async function updateAutomation(
  transport: WebUIMutationTransport,
  id: string,
  values: AutomationUpdatePayload,
): Promise<AutomationsPayload> {
  return mutation<AutomationsPayload>(transport, "automation.update", { id, values });
}

export async function fetchSubagentTasks(token: string, sessionKey: string): Promise<SubagentTasksPayload> {
  const payload = await request<unknown>(
    `/api/sessions/${encodeURIComponent(sessionKey)}/subagents`, token, undefined, API_READ_TIMEOUT_MS,
  );
  if (!isRecord(payload) || !Array.isArray(payload.tasks) || !payload.tasks.every(isSubagentTask)
    || new Set(payload.tasks.map((task) => task.task_id)).size !== payload.tasks.length) {
    throw new Error("Invalid subagent tasks response");
  }
  return { tasks: payload.tasks };
}

export async function fetchSubagentThread(
  token: string, sessionKey: string, taskId: string, signal?: AbortSignal,
): Promise<WebuiThreadPersistedPayload> {
  const payload = await request<unknown>(
    `/api/sessions/${encodeURIComponent(sessionKey)}/subagents/${encodeURIComponent(taskId)}/webui-thread`,
    token, { signal, cache: "no-store" }, API_READ_TIMEOUT_MS,
  );
  return parseWebuiThreadPayload(payload);
}

export async function cancelSubagentTask(
  transport: WebUIMutationTransport, sessionKey: string, taskId: string,
): Promise<SubagentTaskSnapshot> {
  const result = await mutation<unknown>(transport, "subagent.cancel", {
    session_key: sessionKey, task_id: taskId,
  });
  if (!isSubagentTask(result) || result.task_id !== taskId) throw new Error("Invalid subagent cancellation response");
  return result;
}

export async function fetchSkills(
  token: string,
  base: string = "",
): Promise<SkillsPayload> {
  return request<SkillsPayload>(
    `${base}/api/webui/skills`,
    token,
    undefined,
    API_READ_TIMEOUT_MS,
  );
}

export async function fetchSkillDetail(
  token: string,
  name: string,
  base: string = "",
): Promise<SkillDetail> {
  return request<SkillDetail>(
    `${base}/api/webui/skills/${encodeURIComponent(name)}`,
    token,
    undefined,
    API_READ_TIMEOUT_MS,
  );
}

export async function updateSkillEnabled(
  transport: WebUIMutationTransport,
  name: string,
  enabled: boolean,
): Promise<SkillActionPayload> {
  return mutation<SkillActionPayload>(transport, "skill.update", { name, enabled });
}

export async function deleteSkill(
  transport: WebUIMutationTransport,
  name: string,
): Promise<SkillActionPayload> {
  return mutation<SkillActionPayload>(transport, "skill.delete", { name });
}

export async function searchMarketplaceSkills(
  token: string,
  query: string,
  provider: MarketplaceProvider = "all",
  base: string = "",
): Promise<SkillsSearchPayload> {
  const params = new URLSearchParams({ q: query, provider });
  return request<SkillsSearchPayload>(
    `${base}/api/webui/skills/search?${params}`,
    token,
    undefined,
    API_READ_TIMEOUT_MS,
  );
}

export async function fetchTrendingMarketplaceSkills(
  token: string,
  provider: MarketplaceProvider = "all",
  base: string = "",
): Promise<SkillsTrendingPayload> {
  const params = new URLSearchParams({ provider });
  return request<SkillsTrendingPayload>(
    `${base}/api/webui/skills/trending?${params}`,
    token,
    undefined,
    API_READ_TIMEOUT_MS,
  );
}

export async function fetchMarketplaceSkillTrends(
  token: string,
  skillIds: string[],
  base: string = "",
): Promise<SkillsTrendsPayload> {
  const params = new URLSearchParams();
  skillIds.forEach((id) => params.append("id", id));
  return request<SkillsTrendsPayload>(
    `${base}/api/webui/skills/trends?${params}`,
    token,
    undefined,
    API_READ_TIMEOUT_MS,
  );
}

export async function installMarketplaceSkill(
  transport: WebUIMutationTransport,
  provider: Exclude<MarketplaceProvider, "all">,
  source: string,
  skill: string,
  version: string = "",
): Promise<SkillInstallPayload> {
  return mutation<SkillInstallPayload>(
    transport,
    "skill.install",
    { provider, source, skill, ...(version ? { version } : {}) },
    PACKAGE_MUTATION_TIMEOUT_MS,
  );
}

export async function deleteSession(
  transport: WebUIMutationTransport,
  key: string,
  optionsOrBase?: { deleteAutomations?: boolean } | string,
): Promise<SessionDeleteResult> {
  const options = typeof optionsOrBase === "string" ? undefined : optionsOrBase;
  return mutation<SessionDeleteResult>(
    transport,
    "session.delete",
    {
      key,
      ...(options?.deleteAutomations ? { delete_automations: true } : {}),
    },
  );
}

export async function fetchSettings(
  token: string,
  base: string = "",
): Promise<SettingsPayload> {
  return request<SettingsPayload>(
    `${base}/api/settings`,
    token,
    undefined,
    API_READ_TIMEOUT_MS,
  );
}

export async function fetchSettingsUsage(
  token: string,
  base: string = "",
): Promise<NonNullable<SettingsPayload["usage"]>> {
  return request<NonNullable<SettingsPayload["usage"]>>(
    `${base}/api/settings/usage`,
    token,
    undefined,
    API_READ_TIMEOUT_MS,
  );
}

export type UpdateChannel = "stable" | "preview";
export interface ReleaseStatus {
  channel: UpdateChannel;
  revision: number;
  currentVersion: string;
  state: "available" | "current" | "ahead" | "waiting_stable" | "withdrawn" | "unavailable" | "publishing" | "unsupported";
}
export interface VersionCheckResult {
  installation_method?: UpdateMethod | null;
  releaseStatus?: ReleaseStatus;
  can_change_channel?: boolean;
  updateAvailable: {
    currentVersion: string;
    latestVersion: string;
    pypiUrl?: string;
    releaseUrl?: string;
  } | null;
}

export async function checkVersion(
  token: string,
  base: string = "",
  channelStatus = false,
): Promise<VersionCheckResult> {
  return request<VersionCheckResult>(
    `${base}/api/settings/version-check${channelStatus ? "?channel_status=1" : ""}`,
    token,
    undefined,
    90_000,
  );
}

export function changeUpdateChannel(transport: WebUIMutationTransport, channel: UpdateChannel, revision: number): Promise<{ channel: UpdateChannel; revision: number }> {
  return mutation(transport, "settings.nanobot.update.channel", { channel, revision });
}

export async function fetchWorkspaces(
  token: string,
  base: string = "",
): Promise<WorkspacesPayload> {
  return request<WorkspacesPayload>(
    `${base}/api/workspaces`,
    token,
    undefined,
    API_READ_TIMEOUT_MS,
  );
}

export type UpdateMethod = "managed" | "uv" | "pipx" | "pip" | "source" | "container" | "system";
export interface UpdateGuide {
  method: UpdateMethod;
  host: string;
  environment: string;
  shell: "sh" | "powershell";
  inspect_command: string | null;
  update_command: string | null;
  verify_command: string | null;
  reason: "registry" | "preview" | "policy" | "extras" | "manager" | "source" | "container" | "system" | "review" | "restart";
}
export interface UpdateReview {
  id: string;
  installation_id: string;
  host: string;
  running_version: string;
  target_version: string;
  channel?: UpdateChannel;
  action: "upgrade" | "downgrade" | "restart" | "none";
  validity: "current" | "expired" | "installation_changed" | "profiles_changed" | "channel_changed";
  execution_blocked_reason: string | null;
  automatic_recovery?: boolean;
  guide?: UpdateGuide | null;
  profiles: { id: string; workspace: string; reviewed_state: string; stop: boolean; restart: boolean }[];
}
export interface UpdateReviewResponse {
  plan: UpdateReview;
  installation_allowed: boolean;
  execution_available: boolean;
}
export type UpdateJobPhase = "preparation_requested" | "preparing" | "preparation_failed" | "ready"
  | "checking" | "stopping" | "handoff_failed" | "backing_up" | "installing" | "verifying"
  | "installed" | "restarting" | "activating" | "finalizing" | "restart_failed" | "succeeded" | "failed" | "cancelled";
export interface UpdateJob {
  id: string;
  installation_id: string;
  target_version: string;
  running_version: string;
  recorded_phase: UpdateJobPhase;
  recovery_active?: boolean;
  service_restored?: boolean;
  automatic_recovery?: boolean;
  previous_version?: string;
  mutation_started: boolean;
  execution_confirmation_id: string | null;
  recovery_command?: string;
}
export function createUpdateReview(transport: WebUIMutationTransport): Promise<UpdateReviewResponse> {
  return mutation(transport, "settings.nanobot.update.plan", { restart_running: true }, 60_000);
}
export function readUpdateReview(token: string, id: string): Promise<UpdateReviewResponse> {
  return request(`/api/settings/nanobot-update/plan?id=${encodeURIComponent(id)}`, token, undefined, API_READ_TIMEOUT_MS);
}
export function readUpdateJob(token: string, id: string): Promise<{ job: UpdateJob }> {
  return request(`/api/settings/nanobot-update/job?id=${encodeURIComponent(id)}`, token, undefined, API_READ_TIMEOUT_MS);
}
export function prepareUpdate(transport: WebUIMutationTransport, id: string): Promise<{ job: UpdateJob }> {
  return mutation(transport, "settings.nanobot.update.prepare", { id });
}
export function settleUpdate(transport: WebUIMutationTransport, id: string): Promise<{ job: UpdateJob }> {
  return mutation(transport, "settings.nanobot.update.settle", { id });
}
export function executeUpdate(transport: WebUIMutationTransport, id: string, previousConfirmation?: string): Promise<{ job: UpdateJob }> {
  return mutation(transport, previousConfirmation ? "settings.nanobot.update.retry" : "settings.nanobot.update.execute",
    { id, confirm_restart: true, ...(previousConfirmation ? { previous_confirmation_id: previousConfirmation } : {}) });
}

export async function fetchWorkspaceDirectories(
  token: string,
  path: string,
  query: string,
  showHidden: boolean,
  allowPartial = false,
): Promise<WorkspaceDirectoriesPayload> {
  const params = new URLSearchParams({ path, q: query, hidden: showHidden ? "1" : "0", partial: allowPartial ? "1" : "0" });
  return request<WorkspaceDirectoriesPayload>(
    `/api/workspaces/directories?${params}`,
    token,
    undefined,
    API_READ_TIMEOUT_MS,
  );
}

export async function fetchCliApps(
  token: string,
  base: string = "",
): Promise<CliAppsPayload> {
  return request<CliAppsPayload>(
    `${base}/api/settings/cli-apps`,
    token,
    undefined,
    API_READ_TIMEOUT_MS,
  );
}

export async function fetchInstalledCliApps(
  token: string,
  base: string = "",
): Promise<CliAppsPayload> {
  return request<CliAppsPayload>(
    `${base}/api/settings/cli-apps?installed_only=1`,
    token,
    undefined,
    API_READ_TIMEOUT_MS,
  );
}

export async function fetchNanobotFeatures(
  token: string,
  base: string = "",
): Promise<NanobotFeaturesPayload> {
  return request<NanobotFeaturesPayload>(
    `${base}/api/settings/nanobot-features`,
    token,
    undefined,
    API_READ_TIMEOUT_MS,
  );
}

export async function fetchApiService(token: string, base: string = ""): Promise<ApiServicePayload> {
  return request<ApiServicePayload>(`${base}/api/settings/api-service`, token);
}

export async function startApiService(
  transport: WebUIMutationTransport,
  values: { host: string; port: number; timeout: number; apiKey?: string },
): Promise<ApiServicePayload> {
  return mutation<ApiServicePayload>(
    transport,
    "settings.api_service.start",
    {
      host: values.host,
      port: values.port,
      timeout: values.timeout,
      ...(values.apiKey !== undefined ? { api_key: values.apiKey } : {}),
    },
    PACKAGE_MUTATION_TIMEOUT_MS,
  );
}

export async function stopApiService(
  transport: WebUIMutationTransport,
): Promise<ApiServicePayload> {
  return mutation<ApiServicePayload>(transport, "settings.api_service.stop");
}

export async function enableNanobotFeature(
  transport: WebUIMutationTransport,
  name: string,
  options: { instanceId?: string; installOnly?: boolean } = {},
): Promise<NanobotFeaturesPayload> {
  return mutation<NanobotFeaturesPayload>(
    transport,
    "settings.feature.enable",
    {
      name,
      ...(options.instanceId ? { instance_id: options.instanceId } : {}),
      ...(options.installOnly ? { install_only: true } : {}),
    },
    PACKAGE_MUTATION_TIMEOUT_MS,
  );
}

export async function disableNanobotFeature(
  transport: WebUIMutationTransport,
  name: string,
  options: { instanceId?: string } = {},
): Promise<NanobotFeaturesPayload> {
  return mutation<NanobotFeaturesPayload>(
    transport,
    "settings.feature.disable",
    { name, ...(options.instanceId ? { instance_id: options.instanceId } : {}) },
  );
}

export async function fetchPairingRequests(
  token: string,
  base: string = "",
): Promise<PairingPayload> {
  return request<PairingPayload>(
    `${base}/api/settings/pairing`,
    token,
    undefined,
    API_READ_TIMEOUT_MS,
  );
}

export async function runPairingAction(
  transport: WebUIMutationTransport,
  action: "approve" | "deny",
  code: string,
): Promise<PairingPayload> {
  return mutation<PairingPayload>(transport, `settings.pairing.${action}`, { code });
}

export async function startChannelConnect<T = ChannelConnectPayload>(
  transport: WebUIMutationTransport,
  channel: string,
  params: Readonly<Record<string, string | boolean>> = {},
): Promise<T> {
  return mutation<T>(
    transport,
    "settings.channel.connect.start",
    {
      ...params,
      channel,
    },
    PACKAGE_MUTATION_TIMEOUT_MS,
  );
}

export async function pollChannelConnect(
  transport: WebUIMutationTransport,
  channel: string,
  sessionId: string,
  params: Readonly<Record<string, string>> = {},
): Promise<ChannelConnectPayload> {
  const values = Object.fromEntries(
    Object.entries(params).filter(([key]) => key !== "session_id"),
  );
  return mutation<ChannelConnectPayload>(
    transport,
    "settings.channel.connect.poll",
    { channel, session_id: sessionId, ...values },
    PACKAGE_MUTATION_TIMEOUT_MS,
  );
}

export async function cancelChannelConnect(
  transport: WebUIMutationTransport,
  channel: string,
  sessionId: string,
): Promise<ChannelConnectPayload> {
  return mutation<ChannelConnectPayload>(
    transport,
    "settings.channel.connect.cancel",
    { channel, session_id: sessionId },
  );
}

export async function configureChannel(
  transport: WebUIMutationTransport,
  name: string,
  values: Record<string, string | null>,
  options: { enable?: boolean; instanceId?: string } = {},
): Promise<ChannelConfigurePayload> {
  return mutation<ChannelConfigurePayload>(
    transport,
    "settings.channel.configure",
    {
      name,
      values,
      ...(options.enable !== undefined ? { enable: options.enable } : {}),
      ...(options.instanceId ? { instance_id: options.instanceId } : {}),
    },
    PACKAGE_MUTATION_TIMEOUT_MS,
  );
}

export async function validateChannel(
  transport: WebUIMutationTransport,
  name: string,
  values: Record<string, string | null> = {},
  options: { instanceId?: string } = {},
): Promise<ChannelValidationPayload> {
  return mutation<ChannelValidationPayload>(
    transport,
    "settings.channel.validate",
    { name, values, ...(options.instanceId ? { instance_id: options.instanceId } : {}) },
  );
}

export async function runCliAppAction(
  transport: WebUIMutationTransport,
  action: "install" | "update" | "uninstall" | "test",
  name: string,
): Promise<CliAppsPayload> {
  return mutation<CliAppsPayload>(
    transport,
    `settings.cli_app.${action}`,
    { name },
    action === "install" || action === "update"
      ? PACKAGE_MUTATION_TIMEOUT_MS
      : API_MUTATION_TIMEOUT_MS,
  );
}

export async function fetchMcpPresets(
  token: string,
  base: string = "",
): Promise<McpPresetsPayload> {
  return request<McpPresetsPayload>(
    `${base}/api/settings/mcp-presets`,
    token,
    undefined,
    API_READ_TIMEOUT_MS,
  );
}

export async function startMcpOAuth(
  transport: WebUIMutationTransport,
  name: string,
  reset: boolean = false,
  values: Record<string, string> = {},
): Promise<McpOAuthFlowPayload> {
  return mutation<McpOAuthFlowPayload>(
    transport,
    "settings.mcp.oauth_start",
    { ...values, name, ...(reset ? { reset: true } : {}) },
    30_000,
  );
}

export async function fetchMcpOAuthStatus(
  token: string,
  flowId: string,
  base: string = "",
): Promise<McpOAuthFlowPayload> {
  const query = new URLSearchParams({ flow_id: flowId });
  return request<McpOAuthFlowPayload>(
    `${base}/api/settings/mcp-oauth/status?${query}`,
    token,
    undefined,
    API_READ_TIMEOUT_MS,
  );
}

export async function completeMcpOAuth(
  transport: WebUIMutationTransport,
  flowId: string,
  callbackUrl: string,
): Promise<McpOAuthFlowPayload> {
  return mutation<McpOAuthFlowPayload>(
    transport,
    "settings.mcp.oauth_complete",
    { flow_id: flowId, callback_url: callbackUrl },
  );
}

export async function cancelMcpOAuth(
  transport: WebUIMutationTransport,
  flowId: string,
): Promise<McpOAuthFlowPayload> {
  return mutation<McpOAuthFlowPayload>(
    transport,
    "settings.mcp.oauth_cancel",
    { flow_id: flowId },
  );
}

export async function fetchAutomaticModelAPI(
  token: string,
  provider: string,
  model: string,
  reasoningEffort: string,
  base: string = "",
): Promise<AutomaticModelAPIPayload> {
  const query = new URLSearchParams({ provider, model, reasoning_effort: reasoningEffort });
  const payload = await request<unknown>(
    `${base}/api/settings/model-api?${query}`, token, undefined, API_READ_TIMEOUT_MS,
  );
  if (typeof payload !== "object" || payload === null) throw new Error("Invalid model API resolution");
  const result = payload as Record<string, unknown>;
  const api = result.api;
  if (typeof result.provider !== "string" || (
    api !== "chat_completions" && api !== "responses" && api !== "anthropic_messages"
    && api !== "bedrock_converse" && api !== "transcription"
  )) throw new Error("Invalid model API resolution");
  return { provider: result.provider, api };
}

export async function fetchProviderModels(
  token: string,
  provider: string,
  base: string = "",
  options?: { refresh?: boolean },
): Promise<ProviderModelsPayload> {
  const query = new URLSearchParams();
  query.set("provider", provider);
  if (options?.refresh) query.set("refresh", "1");
  return request<ProviderModelsPayload>(
    `${base}/api/settings/provider-models?${query}`,
    token,
    undefined,
    API_READ_TIMEOUT_MS,
  );
}

export async function runMcpPresetAction(
  transport: WebUIMutationTransport,
  action: "enable" | "disable" | "remove" | "test" | "reconnect" | "proxy",
  name: string,
  values: Record<string, string> = {},
): Promise<McpPresetsPayload> {
  return mutation<McpPresetsPayload>(
    transport,
    `settings.mcp.${action}`,
    { name, ...compactMcpValues(values) },
  );
}

export async function saveCustomMcpServer(
  transport: WebUIMutationTransport,
  values: Record<string, string>,
): Promise<McpPresetsPayload> {
  return mutation<McpPresetsPayload>(
    transport,
    "settings.mcp.custom",
    compactMcpValues(values),
  );
}

export async function importMcpConfig(
  transport: WebUIMutationTransport,
  config: string,
): Promise<McpPresetsPayload> {
  return mutation<McpPresetsPayload>(transport, "settings.mcp.import", { config });
}

export async function updateMcpServerTools(
  transport: WebUIMutationTransport,
  name: string,
  enabledTools: string[],
): Promise<McpPresetsPayload> {
  return mutation<McpPresetsPayload>(
    transport,
    "settings.mcp.tools",
    { name, enabled_tools: enabledTools },
  );
}

export async function listSlashCommands(
  token: string,
  base: string = "",
): Promise<SlashCommand[]> {
  type Row = {
    command: string;
    title: string;
    description: string;
    icon: string;
    arg_hint?: string;
    lifecycle?: unknown;
    accepts_args?: unknown;
  };
  const body = await request<{ commands: Row[] }>(
    `${base}/api/commands`,
    token,
    undefined,
    API_READ_TIMEOUT_MS,
  );
  return body.commands
    .flatMap((command) => {
      if (!isSlashCommandLifecycle(command.lifecycle)) return [];
      return [{
        command: command.command,
        title: command.title,
        description: command.description,
        icon: command.icon,
        argHint: command.arg_hint ?? "",
        lifecycle: command.lifecycle,
        acceptsArgs: command.accepts_args === true,
      }];
    });
}

export async function fetchSidebarState(
  token: string,
  base: string = "",
): Promise<SidebarStatePayload> {
  return request<SidebarStatePayload>(
    `${base}/api/webui/sidebar-state`,
    token,
    undefined,
    API_READ_TIMEOUT_MS,
  );
}

function modelGenerationSettingsPayload(
  configuration: Pick<
    ModelConfigurationCreate,
    "maxTokens" | "contextWindowTokens" | "temperature" | "reasoningEffort" | "api" | "extraHeaders" | "extraQuery" | "extraBody"
  >,
): Record<string, unknown> {
  const payload: Record<string, unknown> = {};
  if (configuration.maxTokens !== undefined) {
    payload.max_tokens = configuration.maxTokens;
  }
  if (configuration.contextWindowTokens !== undefined) {
    payload.context_window_tokens = configuration.contextWindowTokens;
  }
  if (configuration.temperature !== undefined) {
    payload.temperature = configuration.temperature;
  }
  if (configuration.reasoningEffort !== undefined) {
    payload.reasoning_effort = configuration.reasoningEffort ?? "";
  }
  if (configuration.api !== undefined) {
    payload.api = configuration.api;
  }
  for (const [key, field] of [
    ["extraHeaders", "extra_headers"], ["extraQuery", "extra_query"], ["extraBody", "extra_body"],
  ] as const) {
    if (configuration[key] !== undefined) payload[field] = configuration[key];
  }
  return payload;
}

export async function createModelConfiguration(
  transport: WebUIMutationTransport,
  configuration: ModelConfigurationCreate,
): Promise<SettingsPayload> {
  return mutation<SettingsPayload>(
    transport,
    "settings.model_configuration.create",
    {
      name: configuration.name,
      provider: configuration.provider,
      model: configuration.model,
      ...modelGenerationSettingsPayload(configuration),
    },
  );
}

export async function updateModelConfiguration(
  transport: WebUIMutationTransport,
  configuration: ModelConfigurationUpdate,
): Promise<SettingsPayload> {
  return mutation<SettingsPayload>(
    transport,
    "settings.model_configuration.update",
    {
      name: configuration.name,
      ...(configuration.newName !== undefined ? { new_name: configuration.newName } : {}),
      ...(configuration.provider !== undefined ? { provider: configuration.provider } : {}),
      ...(configuration.model !== undefined ? { model: configuration.model } : {}),
      ...modelGenerationSettingsPayload(configuration),
    },
  );
}

export async function deleteModelConfiguration(
  transport: WebUIMutationTransport,
  name: string,
): Promise<SettingsPayload> {
  return mutation<SettingsPayload>(
    transport,
    "settings.model_configuration.delete",
    { name },
  );
}

export async function migrateModelConfigurations(
  transport: WebUIMutationTransport,
): Promise<SettingsPayload> {
  return mutation<SettingsPayload>(transport, "settings.model_configuration.migrate");
}

export async function updateModelCallOrder(
  transport: WebUIMutationTransport,
  order: string[],
): Promise<SettingsPayload> {
  return mutation<SettingsPayload>(transport, "settings.model_call_order.update", { order });
}

export async function updateProviderSettings(
  transport: WebUIMutationTransport,
  update: ProviderSettingsUpdate,
): Promise<SettingsPayload> {
  return mutation<SettingsPayload>(transport, "settings.provider.update", { ...update });
}

export async function createProviderSettings(
  transport: WebUIMutationTransport,
  update: ProviderCreationUpdate,
): Promise<SettingsPayload> {
  return mutation<SettingsPayload>(transport, "settings.provider.create", { ...update });
}

export async function loginProviderOAuth(
  transport: WebUIMutationTransport,
  provider: string,
  remoteBrowserAccess: boolean = false,
): Promise<ProviderOAuthLoginResult> {
  return mutation<ProviderOAuthLoginResult>(
    transport,
    "settings.provider.oauth_login",
    { provider, ...(remoteBrowserAccess ? { remote_browser: true } : {}) },
  );
}

export async function completeProviderOAuth(
  transport: WebUIMutationTransport,
  provider: string,
  flowId: string,
  authorizationResponse?: string,
): Promise<ProviderOAuthCompletionResult> {
  return mutation<ProviderOAuthCompletionResult>(
    transport,
    "settings.provider.oauth_complete",
    {
      provider,
      flow_id: flowId,
      ...(authorizationResponse ? { authorization_response: authorizationResponse } : {}),
    },
  );
}

export async function cancelProviderOAuth(
  transport: WebUIMutationTransport,
  provider: string,
  flowId: string,
): Promise<void> {
  await mutation(transport, "settings.provider.oauth_complete", {
    provider, flow_id: flowId, cancel: true,
  });
}

export async function logoutProviderOAuth(
  transport: WebUIMutationTransport,
  provider: string,
): Promise<SettingsPayload> {
  return mutation<SettingsPayload>(transport, "settings.provider.oauth_logout", { provider });
}

export async function updateWebSearchSettings(
  transport: WebUIMutationTransport,
  update: WebSearchSettingsUpdate,
): Promise<SettingsPayload> {
  return mutation<SettingsPayload>(
    transport,
    "settings.web_search.update",
    {
      provider: update.provider,
      ...(update.apiKey !== undefined ? { api_key: update.apiKey } : {}),
      ...(update.baseUrl !== undefined ? { base_url: update.baseUrl } : {}),
      ...(update.maxResults !== undefined ? { max_results: update.maxResults } : {}),
      ...(update.timeout !== undefined ? { timeout: update.timeout } : {}),
      ...(update.useJinaReader !== undefined
        ? { use_jina_reader: update.useJinaReader }
        : {}),
    },
  );
}

export async function updateNetworkSafetySettings(
  transport: WebUIMutationTransport,
  update: NetworkSafetySettingsUpdate,
): Promise<SettingsPayload> {
  return mutation<SettingsPayload>(
    transport,
    "settings.network_safety.update",
    {
      webui_allow_local_service_access: update.webuiAllowLocalServiceAccess,
      webui_default_access_mode: update.webuiDefaultAccessMode,
    },
  );
}

export async function updateImageGenerationSettings(
  transport: WebUIMutationTransport,
  update: ImageGenerationSettingsUpdate,
): Promise<SettingsPayload> {
  return mutation<SettingsPayload>(
    transport,
    "settings.image_generation.update",
    {
      enabled: update.enabled,
      provider: update.provider,
      model: update.model,
      default_aspect_ratio: update.defaultAspectRatio,
      default_image_size: update.defaultImageSize,
      max_images_per_turn: update.maxImagesPerTurn,
      ...(update.extraHeaders !== undefined ? { extra_headers: update.extraHeaders } : {}),
      ...(update.extraBody !== undefined ? { extra_body: update.extraBody } : {}),
    },
  );
}

export async function updateTranscriptionSettings(
  transport: WebUIMutationTransport,
  update: TranscriptionSettingsUpdate,
): Promise<SettingsPayload> {
  return mutation<SettingsPayload>(
    transport,
    "settings.transcription.update",
    {
      enabled: update.enabled,
      provider: update.provider,
      model: update.model,
      language: update.language,
      max_duration_sec: update.maxDurationSec,
      max_upload_mb: update.maxUploadMb,
    },
  );
}


export async function updateRuntimeConfigSettings(
  transport: WebUIMutationTransport,
  values: Record<string, import("@/lib/types").RuntimeConfigValue>,
): Promise<SettingsPayload> {
  return mutation<SettingsPayload>(transport, "settings.runtime_config.update", { values });
}

export function starPromptAction(
  transport: WebUIMutationTransport,
  action: "claim" | "dismiss",
): Promise<{ show: boolean }> {
  return mutation<{ show: boolean }>(transport, `star_prompt.${action}`);
}