@rethinkingstudio/clawpilot 2.0.0-beta.0 → 2.0.0

package/src/commands/provider-config.ts

@@ -1,275 +0,0 @@
-import { readFile, writeFile, mkdir, readdir } from "fs/promises";
-import { join } from "path";
-import { PROVIDER_REGISTRY } from "./provider-registry.js";
-import { resolveOpenclawConfigPath, resolveOpenclawDir } from "./openclaw-cli.js";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface ProviderEntry {
-  id: string;          // e.g. "anthropic", "custom-<uuid>"
-  type: string;        // provider type key
-  name: string;        // display name from registry
-  baseUrl: string;
-  modelId: string | null;   // model used for this provider
-  keyMasked: string | null; // e.g. "sk-a***xyz", null if no key
-  hasKey: boolean;
-  isDefault: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-function maskKey(key: string): string {
-  if (key.length <= 8) return key.slice(0, 2) + "***" + key.slice(-2);
-  return key.slice(0, 4) + "***" + key.slice(-4);
-}
-
-async function resolveAgentId(): Promise<string> {
-  const agentsDir = join(resolveOpenclawDir(), "agents");
-  try {
-    const entries = await readdir(agentsDir, { withFileTypes: true });
-    const dirs = entries.filter(e => e.isDirectory()).map(e => e.name);
-    if (dirs.length > 0) return dirs[0];
-  } catch {
-    // agents dir missing or unreadable
-  }
-  return "main";
-}
-
-async function readJson(filePath: string): Promise<Record<string, unknown>> {
-  try {
-    const raw = await readFile(filePath, "utf-8");
-    return JSON.parse(raw) as Record<string, unknown>;
-  } catch {
-    return {};
-  }
-}
-
-async function writeJson(filePath: string, data: unknown): Promise<void> {
-  await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
-}
-
-function getNestedObj(
-  root: Record<string, unknown>,
-  keys: string[],
-): Record<string, unknown> {
-  let cur: Record<string, unknown> = root;
-  for (const key of keys) {
-    if (cur[key] == null || typeof cur[key] !== "object" || Array.isArray(cur[key])) {
-      cur[key] = {};
-    }
-    cur = cur[key] as Record<string, unknown>;
-  }
-  return cur;
-}
-
-function authProfilesPath(agentId: string): string {
-  return join(resolveOpenclawDir(), "agents", agentId, "agent", "auth-profiles.json");
-}
-
-/** Extract the first model ID from a provider's models array in openclaw.json */
-function extractModelId(providerRaw: Record<string, unknown>): string | null {
-  const models = providerRaw["models"];
-  if (Array.isArray(models) && models.length > 0) {
-    const first = models[0] as Record<string, unknown>;
-    return typeof first["id"] === "string" ? first["id"] : null;
-  }
-  return null;
-}
-
-/** Infer provider type from its id in models.providers */
-function inferType(id: string): string {
-  // custom providers have ids like "custom-<uuid>"
-  if (id.startsWith("custom-")) return "custom";
-  return id;
-}
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-export async function listProviderEntries(): Promise<ProviderEntry[]> {
-  const config = await readJson(resolveOpenclawConfigPath());
-
-  const agentId = await resolveAgentId();
-  const authProfiles = await readJson(authProfilesPath(agentId));
-  const profiles = (authProfiles["profiles"] as Record<string, unknown> | undefined) ?? {};
-
-  // Determine current default
-  const agents = (config["agents"] as Record<string, unknown> | undefined) ?? {};
-  const defaults = (agents["defaults"] as Record<string, unknown> | undefined) ?? {};
-  const model = (defaults["model"] as Record<string, unknown> | undefined) ?? {};
-  const primaryModel = typeof model["primary"] === "string" ? model["primary"] : "";
-
-  const entries: ProviderEntry[] = [];
-
-  // --- Providers from models.providers (non-builtIn) ---
-  const models = (config["models"] as Record<string, unknown> | undefined) ?? {};
-  const providers = (models["providers"] as Record<string, unknown> | undefined) ?? {};
-
-  for (const [id, providerRaw] of Object.entries(providers)) {
-    const p = (providerRaw as Record<string, unknown>) ?? {};
-    const type = inferType(id);
-    const info = PROVIDER_REGISTRY[type];
-    const baseUrl = typeof p["baseUrl"] === "string" ? p["baseUrl"] : "";
-    const modelId = extractModelId(p);
-
-    // auth-profiles key is "${id}:default"
-    const profileKey = `${id}:default`;
-    const profileRaw = profiles[profileKey];
-    const profile = profileRaw != null && typeof profileRaw === "object" && !Array.isArray(profileRaw)
-      ? (profileRaw as Record<string, unknown>)
-      : null;
-    const apiKey = profile != null && typeof profile["key"] === "string" ? profile["key"] : null;
-
-    const hasKey = apiKey != null && apiKey.length > 0;
-    const keyMasked = hasKey ? maskKey(apiKey!) : null;
-    const isDefault = primaryModel === id || primaryModel.startsWith(`${id}/`);
-
-    entries.push({
-      id,
-      type,
-      name: info?.displayName ?? type,
-      baseUrl,
-      modelId,
-      keyMasked,
-      hasKey,
-      isDefault,
-    });
-  }
-
-  // --- Built-in providers (anthropic, google) — detected via auth-profiles ---
-  for (const [type, info] of Object.entries(PROVIDER_REGISTRY)) {
-    if (!info.builtIn) continue;
-    const profileKey = `${type}:default`;
-    const profileRaw = profiles[profileKey];
-    if (profileRaw == null) continue;  // not configured
-
-    const profile = typeof profileRaw === "object" && !Array.isArray(profileRaw)
-      ? (profileRaw as Record<string, unknown>)
-      : null;
-    const apiKey = profile != null && typeof profile["key"] === "string" ? profile["key"] : null;
-    const hasKey = apiKey != null && apiKey.length > 0;
-    const keyMasked = hasKey ? maskKey(apiKey!) : null;
-    const isDefault = primaryModel === type || primaryModel.startsWith(`${type}/`);
-
-    entries.push({
-      id: type,
-      type,
-      name: info.displayName,
-      baseUrl: info.defaultBaseUrl,
-      modelId: info.defaultModelId ?? null,
-      keyMasked,
-      hasKey,
-      isDefault,
-    });
-  }
-
-  return entries;
-}
-
-export async function addProvider(params: {
-  id: string;
-  type: string;
-  apiKey: string | null;
-  baseUrl: string;
-  api: string;
-  apiKeyEnvName: string;  // env var name, written as "apiKey" in openclaw.json
-  modelId?: string;
-}): Promise<void> {
-  const { id, type, apiKey, baseUrl, api, apiKeyEnvName, modelId } = params;
-  const info = PROVIDER_REGISTRY[type];
-
-  // --- Update openclaw.json (skip for builtIn providers) ---
-  if (!info?.builtIn) {
-    const config = await readJson(resolveOpenclawConfigPath());
-    const models = getNestedObj(config, ["models"]);
-    const providers = getNestedObj(models, ["providers"]);
-
-    // "apiKey" is the env var name reference (not the actual key value)
-    const providerEntry: Record<string, unknown> = { type, baseUrl, api, apiKey: apiKeyEnvName };
-    if (modelId !== undefined && modelId.length > 0) {
-      providerEntry["models"] = [{ id: modelId, name: modelId }];
-    }
-    providers[id] = providerEntry;
-
-    await writeJson(resolveOpenclawConfigPath(), config);
-  }
-
-  // --- Update auth-profiles.json (only if apiKey provided) ---
-  if (apiKey != null && apiKey.length > 0) {
-    const agentId = await resolveAgentId();
-    const profilesPath = authProfilesPath(agentId);
-    const profilesDir = join(resolveOpenclawDir(), "agents", agentId, "agent");
-
-    await mkdir(profilesDir, { recursive: true });
-
-    const authProfiles = await readJson(profilesPath);
-    const profiles = getNestedObj(authProfiles, ["profiles"]);
-
-    // Profile key is "${id}:default" — for builtIn, id === type
-    const profileKey = `${id}:default`;
-    profiles[profileKey] = { type: "api_key", provider: type, key: apiKey };
-
-    await writeJson(profilesPath, authProfiles);
-  }
-}
-
-export async function deleteProvider(id: string): Promise<void> {
-  const type = inferType(id);
-  const info = PROVIDER_REGISTRY[type];
-
-  // --- Update openclaw.json (skip for builtIn) ---
-  if (!info?.builtIn) {
-    const config = await readJson(resolveOpenclawConfigPath());
-    const models = getNestedObj(config, ["models"]);
-    const providers = getNestedObj(models, ["providers"]);
-    delete providers[id];
-    await writeJson(resolveOpenclawConfigPath(), config);
-  }
-
-  // --- Update auth-profiles.json ---
-  const agentId = await resolveAgentId();
-  const profilesPath = authProfilesPath(agentId);
-  const authProfiles = await readJson(profilesPath);
-  const profiles = getNestedObj(authProfiles, ["profiles"]);
-
-  const profileKey = `${id}:default`;
-  if (profileKey in profiles) {
-    delete profiles[profileKey];
-    await writeJson(profilesPath, authProfiles);
-  }
-}
-
-export async function setDefaultProvider(id: string): Promise<void> {
-  const type = inferType(id);
-  const info = PROVIDER_REGISTRY[type];
-
-  // Determine the model ID for this provider
-  let modelId: string | null = null;
-
-  if (info?.builtIn) {
-    // Built-in providers: use registry default, no models.providers entry
-    modelId = info.defaultModelId ?? null;
-  } else {
-    // Read from models.providers entry
-    const config = await readJson(resolveOpenclawConfigPath());
-    const models = (config["models"] as Record<string, unknown>) ?? {};
-    const providers = (models["providers"] as Record<string, unknown>) ?? {};
-    const providerRaw = (providers[id] as Record<string, unknown>) ?? {};
-    modelId = extractModelId(providerRaw) ?? info?.defaultModelId ?? null;
-  }
-
-  const primary = modelId ? `${id}/${modelId}` : id;
-
-  const config = await readJson(resolveOpenclawConfigPath());
-  const agents = getNestedObj(config, ["agents"]);
-  const defaults = getNestedObj(agents, ["defaults"]);
-  const model = getNestedObj(defaults, ["model"]);
-  model["primary"] = primary;
-
-  await writeJson(resolveOpenclawConfigPath(), config);
-}

package/src/commands/provider-handlers.ts

@@ -1,184 +0,0 @@
-import { execSync } from "child_process";
-import { randomUUID } from "crypto";
-import type { LocalResult } from "./local-handlers.js";
-import { execOpenclaw, SUBPROCESS_ENV } from "./openclaw-cli.js";
-import { PROVIDER_REGISTRY } from "./provider-registry.js";
-import {
-  listProviderEntries,
-  addProvider,
-  deleteProvider,
-  setDefaultProvider,
-} from "./provider-config.js";
-
-function restartGateway(): void {
-  try {
-    execOpenclaw("gateway restart");
-    console.log("[provider] gateway restarted");
-  } catch (err) {
-    console.warn("[provider] gateway restart failed:", String(err));
-  }
-}
-
-// ---------------------------------------------------------------------------
-// HTTP key validation
-// ---------------------------------------------------------------------------
-
-async function validateApiKey(
-  type: string,
-  apiKey: string,
-  baseUrl: string
-): Promise<{ ok: boolean; error?: string }> {
-  const info = PROVIDER_REGISTRY[type];
-  if (!info) return { ok: false, error: `Unknown provider type: ${type}` };
-  if (!info.requiresApiKey || !apiKey) return { ok: true };
-
-  return new Promise((resolve) => {
-    try {
-      const url = new URL(info.validationPath, baseUrl);
-      if (info.validationAuth === "google-query-param") {
-        url.searchParams.set("key", apiKey);
-      }
-
-      const headers: Record<string, string> = {};
-      if (info.validationAuth === "bearer") {
-        headers["Authorization"] = `Bearer ${apiKey}`;
-      } else if (info.validationAuth === "x-api-key") {
-        headers["x-api-key"] = apiKey;
-        headers["anthropic-version"] = "2023-06-01";
-      }
-
-      // Use http or https based on protocol
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const mod = url.protocol === "https:" ? require("https") : require("http");
-      const req = mod.get(
-        {
-          hostname: url.hostname,
-          port: url.port || undefined,
-          path: url.pathname + url.search,
-          headers,
-        },
-        (res: { statusCode?: number; resume: () => void }) => {
-          res.resume(); // drain body
-          const status = res.statusCode ?? 0;
-          if (status >= 200 && status < 300) {
-            resolve({ ok: true });
-          } else if (status === 401 || status === 403) {
-            resolve({ ok: false, error: "API Key 无效" });
-          } else {
-            resolve({ ok: false, error: `验证失败 (HTTP ${status})` });
-          }
-        }
-      );
-      req.setTimeout(10_000, () => {
-        req.destroy();
-        resolve({ ok: false, error: "验证超时" });
-      });
-      req.on("error", (e: Error) => resolve({ ok: false, error: e.message }));
-    } catch (e) {
-      resolve({ ok: false, error: String(e) });
-    }
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Command handlers
-// ---------------------------------------------------------------------------
-
-async function cmdList(): Promise<LocalResult> {
-  try {
-    const providers = await listProviderEntries();
-    return { ok: true, payload: { providers } };
-  } catch (err) {
-    return { ok: false, error: String(err) };
-  }
-}
-
-async function cmdValidateKey(params: Record<string, unknown>): Promise<LocalResult> {
-  try {
-    const type = params.type as string;
-    const apiKey = params.apiKey as string;
-    const baseUrl = (params.baseUrl as string | undefined) ?? PROVIDER_REGISTRY[type]?.defaultBaseUrl ?? "";
-    const result = await validateApiKey(type, apiKey, baseUrl);
-    if (result.ok) return { ok: true };
-    return { ok: false, error: result.error ?? "验证失败" };
-  } catch (err) {
-    return { ok: false, error: String(err) };
-  }
-}
-
-async function cmdAdd(params: Record<string, unknown>): Promise<LocalResult> {
-  try {
-    const type = params.type as string;
-    const apiKey = (params.apiKey as string | null | undefined) ?? null;
-    const info = PROVIDER_REGISTRY[type];
-    if (!info) return { ok: false, error: `Unknown provider type: ${type}` };
-
-    const baseUrl = (params.baseUrl as string | undefined) || info.defaultBaseUrl;
-    const modelId = (params.modelId as string | undefined) ?? info.defaultModelId;
-
-    // Validate key before writing config
-    if (info.requiresApiKey && apiKey) {
-      const v = await validateApiKey(type, apiKey, baseUrl);
-      if (!v.ok) return { ok: false, error: v.error ?? "API Key 无效" };
-    }
-
-    // custom providers get a UUID suffix; id and apiKeyEnvName share the same UUID so they're traceable
-    const uuid = info.allowMultiple ? randomUUID() : null;
-    const id = uuid ? `custom-${uuid}` : type;
-    const apiKeyEnvName = uuid
-      ? `CUSTOM_${uuid.replace(/-/g, "_").toUpperCase()}_API_KEY`
-      : info.apiKeyEnvName;
-
-    await addProvider({ id, type, apiKey, baseUrl, api: info.api, apiKeyEnvName, modelId });
-    restartGateway();
-    return { ok: true, payload: { id } };
-  } catch (err) {
-    return { ok: false, error: String(err) };
-  }
-}
-
-async function cmdDelete(params: Record<string, unknown>): Promise<LocalResult> {
-  try {
-    const id = params.id as string;
-    if (!id) return { ok: false, error: "id required" };
-    await deleteProvider(id);
-    restartGateway();
-    return { ok: true };
-  } catch (err) {
-    return { ok: false, error: String(err) };
-  }
-}
-
-async function cmdSetDefault(params: Record<string, unknown>): Promise<LocalResult> {
-  try {
-    const id = params.id as string;
-    if (!id) return { ok: false, error: "id required" };
-    await setDefaultProvider(id);
-    restartGateway();
-    return { ok: true };
-  } catch (err) {
-    return { ok: false, error: String(err) };
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Main dispatch
-// ---------------------------------------------------------------------------
-
-export function handleProviderCommand(
-  method: string,
-  params: unknown
-): Promise<LocalResult> | null {
-  if (!method.startsWith("clawpilot.provider.")) return null;
-  const p = (params ?? {}) as Record<string, unknown>;
-
-  switch (method) {
-    case "clawpilot.provider.list":       return cmdList();
-    case "clawpilot.provider.validateKey": return cmdValidateKey(p);
-    case "clawpilot.provider.add":        return cmdAdd(p);
-    case "clawpilot.provider.delete":     return cmdDelete(p);
-    case "clawpilot.provider.setDefault": return cmdSetDefault(p);
-    default:
-      return Promise.resolve({ ok: false, error: `Unknown provider command: ${method}` });
-  }
-}

package/src/commands/provider-registry.ts

@@ -1,138 +0,0 @@
-export interface ProviderTypeInfo {
-  displayName: string;
-  defaultBaseUrl: string;
-  api: "anthropic-messages" | "openai-completions" | "openai-responses";
-  apiKeyEnvName: string;
-  validationPath: string;
-  validationAuth: "bearer" | "x-api-key" | "google-query-param" | "none";
-  requiresApiKey: boolean;
-  allowMultiple: boolean;
-  showBaseUrl: boolean;
-  showModelId: boolean;
-  defaultModelId?: string;
-  /**
-   * Built-in OpenClaw providers (anthropic, google) — do NOT write a
-   * models.providers entry; only write to auth-profiles.json.
-   */
-  builtIn?: boolean;
-}
-
-export const PROVIDER_REGISTRY: Record<string, ProviderTypeInfo> = {
-  anthropic: {
-    displayName: "Anthropic",
-    defaultBaseUrl: "https://api.anthropic.com",
-    api: "anthropic-messages",
-    apiKeyEnvName: "ANTHROPIC_API_KEY",
-    validationPath: "/v1/models",
-    validationAuth: "x-api-key",
-    requiresApiKey: true,
-    allowMultiple: false,
-    showBaseUrl: false,
-    showModelId: false,
-    defaultModelId: "claude-opus-4-6",
-    builtIn: true,
-  },
-  openai: {
-    displayName: "OpenAI",
-    defaultBaseUrl: "https://api.openai.com",
-    api: "openai-responses",
-    apiKeyEnvName: "OPENAI_API_KEY",
-    validationPath: "/v1/models",
-    validationAuth: "bearer",
-    requiresApiKey: true,
-    allowMultiple: false,
-    showBaseUrl: false,
-    showModelId: false,
-    defaultModelId: "gpt-4o",
-  },
-  google: {
-    displayName: "Google",
-    defaultBaseUrl: "https://generativelanguage.googleapis.com",
-    api: "openai-completions",
-    apiKeyEnvName: "GOOGLE_API_KEY",
-    validationPath: "/v1beta/models",
-    validationAuth: "google-query-param",
-    requiresApiKey: true,
-    allowMultiple: false,
-    showBaseUrl: false,
-    showModelId: false,
-    defaultModelId: "gemini-2.0-flash",
-    builtIn: true,
-  },
-  openrouter: {
-    displayName: "OpenRouter",
-    defaultBaseUrl: "https://openrouter.ai",
-    api: "openai-completions",
-    apiKeyEnvName: "OPENROUTER_API_KEY",
-    validationPath: "/api/v1/models",
-    validationAuth: "bearer",
-    requiresApiKey: true,
-    allowMultiple: false,
-    showBaseUrl: false,
-    showModelId: false,
-    defaultModelId: "anthropic/claude-opus-4-6",
-  },
-  ark: {
-    displayName: "ByteDance (Ark)",
-    defaultBaseUrl: "https://ark.cn-beijing.volces.com",
-    api: "openai-completions",
-    apiKeyEnvName: "ARK_API_KEY",
-    validationPath: "/api/v3/models",
-    validationAuth: "bearer",
-    requiresApiKey: true,
-    allowMultiple: false,
-    showBaseUrl: false,
-    showModelId: true,   // Ark is a platform; user must specify the model endpoint ID
-  },
-  moonshot: {
-    displayName: "Moonshot (Kimi)",
-    defaultBaseUrl: "https://api.moonshot.cn",
-    api: "openai-completions",
-    apiKeyEnvName: "MOONSHOT_API_KEY",
-    validationPath: "/v1/models",
-    validationAuth: "bearer",
-    requiresApiKey: true,
-    allowMultiple: false,
-    showBaseUrl: false,
-    showModelId: false,
-    defaultModelId: "kimi-k2.5",
-  },
-  siliconflow: {
-    displayName: "SiliconFlow",
-    defaultBaseUrl: "https://api.siliconflow.cn",
-    api: "openai-completions",
-    apiKeyEnvName: "SILICONFLOW_API_KEY",
-    validationPath: "/v1/models",
-    validationAuth: "bearer",
-    requiresApiKey: true,
-    allowMultiple: false,
-    showBaseUrl: false,
-    showModelId: false,
-    defaultModelId: "Qwen/QwQ-32B",
-  },
-  ollama: {
-    displayName: "Ollama",
-    defaultBaseUrl: "http://localhost:11434",
-    api: "openai-completions",
-    apiKeyEnvName: "OLLAMA_API_KEY",
-    validationPath: "/api/tags",
-    validationAuth: "none",
-    requiresApiKey: false,
-    allowMultiple: false,
-    showBaseUrl: true,
-    showModelId: true,   // User must specify which model they have pulled
-  },
-  custom: {
-    displayName: "Custom",
-    defaultBaseUrl: "",
-    api: "openai-completions",
-    apiKeyEnvName: "CUSTOM_API_KEY",
-    validationPath: "/v1/models",
-    validationAuth: "bearer",
-    requiresApiKey: false,
-    allowMultiple: true,
-    showBaseUrl: true,
-    showModelId: true,
-    defaultModelId: "custom-model",
-  },
-};

package/src/commands/run.ts

@@ -1,34 +0,0 @@
-import { readConfig, readGatewayUrl, readGatewayAuth } from "../config/config.js";
-import { runRelayManager } from "../relay/relay-manager.js";
-import { withReconnect } from "../relay/reconnect.js";
-import { t } from "../i18n/index.js";
-
-export async function runCommand(): Promise<void> {
-  const config = readConfig();
-  const gatewayUrl = readGatewayUrl();
-  const gatewayAuth = readGatewayAuth(config);
-
-  console.log(t("run.starting"));
-  console.log(t("run.gatewayId", config.gatewayId));
-  console.log(t("run.relayServer", config.relayServerUrl));
-  console.log(t("run.gatewayUrl", gatewayUrl));
-
-  await withReconnect(
-    () =>
-      runRelayManager({
-        relayServerUrl: config.relayServerUrl,
-        gatewayId: config.gatewayId,
-        relaySecret: config.relaySecret,
-        gatewayUrl,
-        gatewayToken: gatewayAuth.token,
-        gatewayPassword: gatewayAuth.password,
-        onConnected: () => console.log(t("run.connected")),
-        onDisconnected: () => console.log(t("run.disconnected")),
-      }),
-    {
-      onRetry: (attempt, delayMs) => {
-        console.log(t("run.retry", String(attempt), String(delayMs)));
-      },
-    }
-  );
-}

package/src/commands/send.ts

@@ -1,42 +0,0 @@
-import { basename } from "path";
-import { t } from "../i18n/index.js";
-import { sendSyntheticAssistantMessage } from "./assistant-send.js";
-import { uploadFile } from "./upload.js";
-
-export interface SendCommandOptions {
-  json?: boolean;
-}
-
-export async function sendCommand(filePath: string, options: SendCommandOptions = {}): Promise<void> {
-  if (!options.json) {
-    console.log(t("send.preparing", filePath));
-  }
-
-  const uploaded = await uploadFile(filePath);
-  const result = await sendSyntheticAssistantMessage({
-    message: "uploaded file",
-    url: uploaded.url,
-    mimeType: uploaded.mimeType,
-    fileName: uploaded.fileName || basename(uploaded.path),
-    thumbnailUrl: uploaded.thumbnailUrl ?? undefined,
-    size: String(uploaded.size),
-  });
-
-  if (options.json) {
-    console.log(JSON.stringify({
-      path: uploaded.path,
-      fileName: uploaded.fileName,
-      mimeType: uploaded.mimeType,
-      url: uploaded.url,
-      thumbnailUrl: uploaded.thumbnailUrl,
-      size: uploaded.size,
-      runId: result.runId,
-      sessionKey: result.sessionKey,
-      messageId: result.messageId,
-    }));
-    return;
-  }
-
-  console.log(t("send.completed", uploaded.fileName, result.sessionKey));
-  console.log(uploaded.url);
-}