@blade-hq/agent-kit 0.4.1 → 0.4.5

package/dist/client/index.js

@@ -0,0 +1,1076 @@
+// src/client/rest.ts
+var BladeApiError = class extends Error {
+  response;
+  status;
+  statusText;
+  constructor(response, message) {
+    super(message ?? `Blade API request failed with ${response.status} ${response.statusText}`);
+    this.name = "BladeApiError";
+    this.response = response;
+    this.status = response.status;
+    this.statusText = response.statusText;
+  }
+};
+
+// src/client/resources/api-keys.ts
+var ApiKeysResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  listApiKeys() {
+    return this.client.json("GET", "/api/user/api-keys/");
+  }
+  createApiKey(name) {
+    return this.client.json("POST", "/api/user/api-keys/", { name });
+  }
+  renameApiKey(id, name) {
+    return this.client.json("PATCH", `/api/user/api-keys/${encodeURIComponent(id)}`, { name });
+  }
+  async deleteApiKey(id) {
+    try {
+      await this.client.json("DELETE", `/api/user/api-keys/${encodeURIComponent(id)}`);
+    } catch (err) {
+      if (err instanceof BladeApiError) {
+        const detail = await readErrorDetail(err.response);
+        if (detail) {
+          throw new Error(detail);
+        }
+      }
+      throw err;
+    }
+  }
+};
+async function readErrorDetail(response) {
+  try {
+    const data = await response.clone().json();
+    const detail = data?.detail;
+    return typeof detail === "string" && detail.trim() ? detail : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/client/resources/auth.ts
+var AuthResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  getProviders() {
+    return this.client.json("GET", "/api/auth/providers");
+  }
+  getMe() {
+    return this.client.json("GET", "/api/auth/me");
+  }
+  logout() {
+    return this.client.json("POST", "/api/auth/logout");
+  }
+};
+
+// src/client/resources/gis.ts
+var GisResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  fetchGisState(sessionId, init) {
+    return this.client.jsonFromInit(`/api/gis/${sessionId}/state`, init);
+  }
+  fetchRuntimeConfig(init) {
+    return this.client.jsonFromInit("/api/config", init);
+  }
+};
+
+// src/client/resources/licenses.ts
+var LicensesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  getDeviceUuid() {
+    return this.client.json("GET", "/api/licenses/device-uuid");
+  }
+  validateLicense() {
+    return this.client.json("GET", "/api/licenses/validate");
+  }
+  getLicenseStatus() {
+    return this.client.json("GET", "/api/licenses/status");
+  }
+  async uploadLicense(file) {
+    const formData = new FormData();
+    formData.append("file", file);
+    const response = await this.client.formData("POST", "/api/licenses/upload", formData);
+    return response.json();
+  }
+};
+
+// src/client/resources/memories.ts
+var MemoriesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  createMemory(body) {
+    return this.client.json("POST", "/api/memories", body);
+  }
+  listMemories(params) {
+    const search = new URLSearchParams();
+    if (params?.keyword) search.set("keyword", params.keyword);
+    if (params?.skill_name != null) search.set("skill_name", params.skill_name);
+    if (params?.type) search.set("type", params.type);
+    if (params?.record_type) search.set("record_type", params.record_type);
+    if (params?.scope) search.set("scope", params.scope);
+    if (params?.owner) search.set("owner", params.owner);
+    if (params?.topic) search.set("topic", params.topic);
+    if (params?.status) search.set("status", params.status);
+    if (params?.offset !== void 0) search.set("offset", String(params.offset));
+    if (params?.limit !== void 0) search.set("limit", String(params.limit));
+    const qs = search.toString();
+    return this.client.json("GET", `/api/memories${qs ? `?${qs}` : ""}`);
+  }
+  getMemory(id) {
+    return this.client.json("GET", `/api/memories/${id}`);
+  }
+  updateMemory(id, body) {
+    return this.client.json("PUT", `/api/memories/${id}`, body);
+  }
+  patchMemory(id, disabled) {
+    return this.client.json("PATCH", `/api/memories/${id}`, { disabled });
+  }
+  deleteMemory(id) {
+    return this.client.json("DELETE", `/api/memories/${id}`);
+  }
+  batchMemories(action, ids) {
+    return this.client.json("POST", "/api/memories/batch", { action, ids });
+  }
+};
+
+// src/client/resources/models.ts
+import { type } from "arktype";
+var ModelOption = type({
+  id: "string",
+  label: "string"
+});
+var ModelsConfig = type({
+  default: "string",
+  models: ModelOption.array()
+});
+var ModelsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async getModelsConfig(init) {
+    const data = await this.client.jsonFromInit("/api/config/models", init);
+    return ModelsConfig.assert(data);
+  }
+};
+
+// src/client/resources/registry.ts
+var REGISTRY_PREFIX = "/api-registry";
+var API_TO_FRONTEND_TYPE = {
+  tool: "tools",
+  datasource: "data",
+  knowledgebase: "knowledge",
+  agent: "agent"
+};
+function normalizeResource(raw) {
+  return {
+    ...raw,
+    id: String(raw.id),
+    type: API_TO_FRONTEND_TYPE[raw.type] ?? raw.type
+  };
+}
+var RegistryResource = class {
+  constructor(client) {
+    this.client = client;
+    this.databaseApi = this.createResourceApi("datasource");
+    this.toolApi = this.createResourceApi("tool");
+    this.knowledgeApi = this.createResourceApi("knowledgebase");
+    this.agentApi = this.createResourceApi("agent");
+  }
+  client;
+  databaseApi;
+  toolApi;
+  knowledgeApi;
+  agentApi;
+  createResourceApi(apiType) {
+    return {
+      list: (init) => this.client.jsonFromInit(`${REGISTRY_PREFIX}/resources?type=${apiType}`, init).then((response) => (response.items ?? []).map((item) => normalizeResource(item))),
+      get: (id, init) => this.client.jsonFromInit(`${REGISTRY_PREFIX}/resources/${encodeURIComponent(id)}`, init).then((item) => normalizeResource(item)),
+      create: (data, init) => this.client.jsonFromInit(`${REGISTRY_PREFIX}/resources`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(data),
+        ...init
+      }),
+      update: (id, data, init) => this.client.jsonFromInit(`${REGISTRY_PREFIX}/resources/${encodeURIComponent(id)}`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(data),
+        ...init
+      }),
+      delete: async (id, init) => {
+        await this.client.textFromInit(`${REGISTRY_PREFIX}/resources/${encodeURIComponent(id)}`, {
+          method: "DELETE",
+          ...init
+        });
+      }
+    };
+  }
+  listSkillOrgs() {
+    return this.client.json("GET", `${REGISTRY_PREFIX}/skills/orgs`);
+  }
+  publishSkill(sessionId, org, version) {
+    return this.client.json("POST", `/api/sessions/${encodeURIComponent(sessionId)}/skill-publish`, {
+      org,
+      version
+    });
+  }
+};
+
+// src/client/resources/scenarios.ts
+var ScenariosResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  listQuickScenarios(init) {
+    return this.client.jsonFromInit("/api/scenarios", init);
+  }
+  createQuickScenario(payload, init) {
+    return this.client.jsonFromInit("/api/scenarios", {
+      method: "POST",
+      body: JSON.stringify(payload),
+      ...init
+    });
+  }
+  deleteQuickScenario(scenarioId, init) {
+    return this.client.jsonFromInit(`/api/scenarios/${scenarioId}`, {
+      method: "DELETE",
+      ...init
+    });
+  }
+  updateQuickScenario(scenarioId, payload, init) {
+    return this.client.jsonFromInit(`/api/scenarios/${scenarioId}`, {
+      method: "PUT",
+      body: JSON.stringify(payload),
+      ...init
+    });
+  }
+  async listBladeHubScenarioResources(limit = 500, init) {
+    const params = new URLSearchParams({ limit: String(limit) });
+    const response = await this.client.jsonFromInit(
+      `/api/skills/scenario-resources?${params}`,
+      init
+    );
+    return response.items ?? [];
+  }
+};
+
+// src/client/resources/sessions.ts
+function toCreateSessionPayload(request) {
+  return {
+    intent: request.intent ?? "",
+    template_id: request.template_id,
+    solution_id: request.solution_id,
+    biz_role_id: request.biz_role_id ?? null,
+    model: request.model ?? null,
+    memory_enabled: request.memory_enabled ?? null,
+    primary_skill_id: request.primary_skill_id ?? null,
+    software_factory_id: request.software_factory_id ?? null
+  };
+}
+var SessionsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  fetchSessionsPage({
+    limit,
+    offset,
+    template_id_prefix,
+    q
+  }) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("limit", String(limit));
+    searchParams.set("offset", String(offset));
+    if (template_id_prefix) searchParams.set("template_id_prefix", template_id_prefix);
+    const trimmedQuery = q?.trim();
+    if (trimmedQuery) searchParams.set("q", trimmedQuery);
+    return this.client.json("GET", `/api/sessions?${searchParams.toString()}`);
+  }
+  async listSessions(template_id_prefix) {
+    const pageSize = 100;
+    const sessions = [];
+    let offset = 0;
+    while (true) {
+      const page = await this.fetchSessionsPage({ limit: pageSize, offset, template_id_prefix });
+      sessions.push(...page.items);
+      if (sessions.length >= page.total || page.items.length === 0) return sessions;
+      offset += page.items.length;
+    }
+  }
+  listSessionsPaginated(params) {
+    return this.fetchSessionsPage(params);
+  }
+  listSessionsWithSkillData() {
+    return this.client.json("GET", "/api/sessions/with-skill-data");
+  }
+  createSession(intent, template_id, primary_skill_id) {
+    return this.createSessionWithRequest({ intent, template_id, primary_skill_id });
+  }
+  createSessionWithRequest(request) {
+    return this.client.json("POST", "/api/sessions", toCreateSessionPayload(request));
+  }
+  getSession(sessionId, init) {
+    return this.client.jsonFromInit(`/api/sessions/${sessionId}`, init);
+  }
+  updateSession(sessionId, payload) {
+    return this.client.json("PATCH", `/api/sessions/${sessionId}`, payload);
+  }
+  pinSession(sessionId, pinned) {
+    return this.client.json("PATCH", `/api/sessions/${sessionId}/pin`, { pinned });
+  }
+  startReplaySession(sourceSessionId, speed = 5) {
+    return this.client.json("POST", `/api/sessions/${sourceSessionId}/replay`, { speed });
+  }
+  updateReplaySession(sessionId, payload) {
+    return this.client.json("PATCH", `/api/sessions/${sessionId}/replay`, payload);
+  }
+  updateSharing(sessionId, shared) {
+    return this.client.json("PATCH", `/api/sessions/${sessionId}/sharing`, { shared });
+  }
+  updateSessionMemory(sessionId, memoryEnabled) {
+    return this.client.json("PATCH", `/api/sessions/${sessionId}/memory`, {
+      memory_enabled: memoryEnabled
+    });
+  }
+  createShare(sessionId) {
+    return this.client.json("POST", `/api/sessions/${sessionId}/share`, {});
+  }
+  revokeShare(sessionId, token) {
+    return this.client.json("DELETE", `/api/sessions/${sessionId}/share/${encodeURIComponent(token)}`);
+  }
+  getSharedSession(token) {
+    return this.client.jsonFromInit(`/api/share/${encodeURIComponent(token)}`, {
+      credentials: "omit",
+      headers: { Accept: "application/json" }
+    });
+  }
+  getSessionTasks(sessionId) {
+    return this.client.json("GET", `/api/sessions/${sessionId}/tasks`);
+  }
+  getSessionTurns(sessionId) {
+    return this.client.json("GET", `/api/sessions/${sessionId}/messages`);
+  }
+  getSessionContextStats(sessionId, init) {
+    return this.client.jsonFromInit(`/api/sessions/${sessionId}/context-stats`, init);
+  }
+  getSessionHistory(sessionId, init) {
+    return this.client.jsonFromInit(`/api/sessions/${sessionId}/history`, init);
+  }
+  tokenizePrompt(prompt, model) {
+    return this.client.json("POST", "/api/sessions/tokenize/prompt", { prompt, model });
+  }
+  tokenizeMessages(messages, options) {
+    return this.client.json("POST", "/api/sessions/tokenize/messages", {
+      messages,
+      model: options?.model,
+      add_generation_prompt: options?.add_generation_prompt ?? true,
+      enable_thinking: options?.enable_thinking ?? null,
+      tools: options?.tools ?? null
+    });
+  }
+  getSessionCheckpoints(sessionId, init) {
+    return this.client.jsonFromInit(`/api/sessions/${sessionId}/checkpoints`, init);
+  }
+  checkoutSession(sessionId, checkpointId, position) {
+    return this.client.json("POST", `/api/sessions/${sessionId}/checkout`, {
+      checkpoint_id: checkpointId,
+      position
+    });
+  }
+  async rewindSession(sessionId, checkpointId) {
+    const result = await this.checkoutSession(sessionId, checkpointId, "before");
+    return { id: result.id, content: result.content };
+  }
+  switchBranch(sessionId, checkpointId) {
+    return this.client.json("POST", `/api/sessions/${sessionId}/switch-branch`, {
+      checkpoint_id: checkpointId
+    });
+  }
+  deleteSession(sessionId) {
+    return this.client.json("DELETE", `/api/sessions/${sessionId}`);
+  }
+  listBackgroundTasks(sessionId, init) {
+    return this.client.jsonFromInit(`/api/sessions/${sessionId}/background-tasks`, init);
+  }
+  getBackgroundTask(sessionId, taskId, tail = 100, init) {
+    return this.client.jsonFromInit(`/api/sessions/${sessionId}/background-tasks/${taskId}?tail=${tail}`, init);
+  }
+  stopBackgroundTask(sessionId, taskId) {
+    return this.client.json("POST", `/api/sessions/${sessionId}/background-tasks/${taskId}/stop`);
+  }
+  listDir(sessionId, dirPath) {
+    return this.client.json("GET", `/api/sessions/${sessionId}/ls/${encodeURIComponent(dirPath)}`);
+  }
+  async uploadFiles(sessionId, dirPath, files) {
+    const formData = new FormData();
+    const entries = Array.from(files).map(
+      (f) => f instanceof File ? { file: f, name: f.name } : f
+    );
+    for (const entry of entries) {
+      formData.append("files", entry.file, entry.name);
+    }
+    if (entries.some((e) => Boolean(e.file.webkitRelativePath))) {
+      formData.append("paths", JSON.stringify(entries.map((e) => e.file.webkitRelativePath || e.name)));
+    }
+    const response = await this.client.formData(
+      "POST",
+      `/api/sessions/${sessionId}/upload/${encodeURIComponent(dirPath)}`,
+      formData,
+      { expectOk: false }
+    );
+    return response.json();
+  }
+  async deleteFile(sessionId, filePath) {
+    await this.client.json("DELETE", `/api/sessions/${sessionId}/files/${encodeURIComponent(filePath)}`);
+  }
+  writeFile(sessionId, filePath, content) {
+    return this.client.json("PUT", `/api/sessions/${sessionId}/files/${encodeURIComponent(filePath)}`, {
+      content
+    });
+  }
+  renameFile(sessionId, filePath, newName) {
+    return this.client.json("POST", `/api/sessions/${sessionId}/files/${encodeURIComponent(filePath)}/rename`, {
+      new_name: newName
+    });
+  }
+  copyFile(sessionId, filePath) {
+    return this.client.json("POST", `/api/sessions/${sessionId}/files/${encodeURIComponent(filePath)}/copy`);
+  }
+  shareFile(sessionId, sourcePath, linkName, shareFolder) {
+    return this.client.json("POST", `/api/sessions/${sessionId}/share-file`, {
+      source_path: sourcePath,
+      link_name: linkName ?? "",
+      share_folder: shareFolder ?? ""
+    });
+  }
+  getDownloadDirUrl(sessionId, dirPath) {
+    return this.client.buildAuthedUrl(`/api/sessions/${sessionId}/download-dir/${encodeURIComponent(dirPath)}`);
+  }
+  async exportSession(sessionId) {
+    await this.getSession(sessionId);
+    const a = document.createElement("a");
+    a.href = this.client.buildAuthedUrl(`/api/sessions/${sessionId}/export`);
+    a.download = `${sessionId}.zip`;
+    document.body.appendChild(a);
+    a.click();
+    a.remove();
+  }
+  async previewImport(file) {
+    const form = new FormData();
+    form.append("file", file);
+    const res = await this.client.formData("POST", "/api/sessions/preview-import", form);
+    return res.json();
+  }
+  async importSession(file, name, solutionId) {
+    const form = new FormData();
+    form.append("file", file);
+    if (name) form.append("name", name);
+    if (solutionId) form.append("solution_id", solutionId);
+    const res = await this.client.formData("POST", "/api/sessions/import", form);
+    return res.json();
+  }
+};
+
+// src/client/resources/skills.ts
+var SkillsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  listSkills(init) {
+    return this.client.jsonFromInit("/api/skills", init);
+  }
+  listSessionSkills(sessionId, init) {
+    return this.client.jsonFromInit(`/api/sessions/${encodeURIComponent(sessionId)}/skills`, init);
+  }
+  resyncSkills(sessionId, init) {
+    return this.client.jsonFromInit(`/api/sessions/${encodeURIComponent(sessionId)}/skills:resync`, {
+      method: "POST",
+      ...init
+    });
+  }
+  async searchSkills(query, limit = 10, init) {
+    const params = new URLSearchParams({ q: query, limit: String(limit) });
+    const response = await this.client.jsonFromInit(
+      `/api/skills/search?${params}`,
+      init
+    );
+    return response.results;
+  }
+  getSkillStats(sessionId, init) {
+    return this.client.jsonFromInit(`/api/sessions/${encodeURIComponent(sessionId)}/skill-stats`, init);
+  }
+  getGlobalSkillStats(init) {
+    return this.client.jsonFromInit("/api/skill-store/stats", init);
+  }
+  getSkill(skillName, init) {
+    return this.client.jsonFromInit(`/api/skills/${encodeURIComponent(skillName)}`, init);
+  }
+  installPartnerSkill(sessionId, payload, init) {
+    return this.client.jsonFromInit(`/api/sessions/${encodeURIComponent(sessionId)}/skills/install`, {
+      method: "POST",
+      body: JSON.stringify(payload),
+      ...init
+    });
+  }
+};
+
+// src/client/resources/software-factory.ts
+var SoftwareFactoryResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  listSoftware() {
+    return this.client.json("GET", "/api/software-factory/software");
+  }
+  getSoftware(softwareId) {
+    return this.client.json("GET", `/api/software-factory/software/${softwareId}`);
+  }
+  deleteSoftware(softwareId) {
+    return this.client.json("DELETE", `/api/software-factory/software/${softwareId}`);
+  }
+  createSoftware(payload) {
+    return this.client.json("POST", "/api/software-factory/software", payload);
+  }
+  updateSoftware(softwareId, payload) {
+    return this.client.json("PATCH", `/api/software-factory/software/${softwareId}`, payload);
+  }
+  bindTopicModuleSession(softwareId, topicKey, moduleKey, sessionId, assignee) {
+    return this.client.json(
+      "PATCH",
+      `/api/software-factory/software/${softwareId}/topics/${topicKey}/modules/${moduleKey}/session`,
+      {
+        session_id: sessionId,
+        assignee_name: assignee?.name ?? null,
+        assignee_type: assignee?.type ?? null
+      }
+    );
+  }
+  submitModuleForReview(softwareId, topicKey, moduleKey, subKey = "default") {
+    return this.client.json(
+      "POST",
+      `/api/software-factory/software/${softwareId}/topics/${topicKey}/modules/${moduleKey}/submit-review`,
+      { sub_key: subKey }
+    );
+  }
+  completeModule(softwareId, topicKey, moduleKey, subKey = "default") {
+    return this.client.json(
+      "POST",
+      `/api/software-factory/software/${softwareId}/topics/${topicKey}/modules/${moduleKey}/complete`,
+      { sub_key: subKey }
+    );
+  }
+  reopenModule(softwareId, topicKey, moduleKey, subKey = "default") {
+    return this.client.json(
+      "POST",
+      `/api/software-factory/software/${softwareId}/topics/${topicKey}/modules/${moduleKey}/reopen`,
+      { sub_key: subKey }
+    );
+  }
+  listSharedFiles(softwareId) {
+    return this.client.json("GET", `/api/software-factory/software/${softwareId}/shared-files`);
+  }
+  createSharedFile(softwareId, payload) {
+    return this.client.json("POST", `/api/software-factory/software/${softwareId}/shared-files`, payload);
+  }
+  async uploadSoftwareDocuments(softwareId, files) {
+    const formData = new FormData();
+    for (const file of files) formData.append("files", file);
+    const res = await this.client.formData(
+      "POST",
+      `/api/software-factory/software/${softwareId}/upload-documents`,
+      formData
+    );
+    return res.json();
+  }
+  ensureIssueSession(softwareId) {
+    return this.client.json("POST", `/api/software-factory/software/${softwareId}/issue-session`);
+  }
+  listCodingTasks(softwareId) {
+    return this.client.json("GET", `/api/software-factory/software/${softwareId}/coding-tasks`);
+  }
+  startCoding(softwareId, payload) {
+    return this.client.json("POST", `/api/software-factory/software/${softwareId}/start-coding`, payload);
+  }
+  readShareFileContent(softwareId, path) {
+    return this.client.json(
+      "GET",
+      `/api/software-factory/software/${softwareId}/share-file-content?path=${encodeURIComponent(path)}`
+    );
+  }
+  syncShare(softwareId) {
+    return this.client.json("POST", `/api/software-factory/software/${softwareId}/sync-share`);
+  }
+  listTopics(softwareId) {
+    return this.client.json("GET", `/api/software-factory/software/${softwareId}/topics`);
+  }
+  replaceTopics(softwareId, topics) {
+    return this.client.json("PUT", `/api/software-factory/software/${softwareId}/topics`, { topics });
+  }
+  getFactoryExportUrl(softwareId) {
+    return this.client.buildAuthedUrl(`/api/software-factory/software/${softwareId}/export`);
+  }
+  async importFactory(file) {
+    const formData = new FormData();
+    formData.append("file", file);
+    const res = await this.client.formData("POST", "/api/software-factory/software/import", formData);
+    return res.json();
+  }
+};
+
+// src/client/resources/solutions.ts
+var SolutionsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async fetchSolutions() {
+    const payload = await this.client.json("GET", "/api/solutions");
+    if (Array.isArray(payload)) {
+      return payload;
+    }
+    return Array.isArray(payload.items) ? payload.items : [];
+  }
+  fetchSolutionFile(solutionId, filePath) {
+    return this.client.text(
+      "GET",
+      `/api/solutions/${encodeURIComponent(solutionId)}/files/${encodeURIComponent(filePath)}`
+    );
+  }
+  async fetchSolutionBizRoles(solutionId, userId) {
+    const params = new URLSearchParams();
+    if (userId) {
+      params.set("user_id", userId);
+    }
+    const suffix = params.toString() ? `?${params.toString()}` : "";
+    const payload = await this.client.json(
+      "GET",
+      `/api/solutions/${encodeURIComponent(solutionId)}/biz-roles${suffix}`
+    );
+    return Array.isArray(payload.items) ? payload.items : [];
+  }
+};
+
+// src/client/resources/user-preferences.ts
+var UserPreferencesResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async getUserPreference(key) {
+    const response = await this.client.json(
+      "GET",
+      `/api/user/preferences/${encodeURIComponent(key)}`
+    );
+    return response.value;
+  }
+  async setUserPreference(key, value) {
+    await this.client.json(
+      "PUT",
+      `/api/user/preferences/${encodeURIComponent(key)}`,
+      { value }
+    );
+  }
+};
+
+// src/client/resources/vibe-coding.ts
+var VibeCodingResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  createVibeCodingSession(params) {
+    return this.client.json("POST", "/api/vibe-coding/sessions", params);
+  }
+  async listVibeCodingSessionInfos() {
+    const result = await this.client.json(
+      "GET",
+      "/api/vibe-coding/sessions/status"
+    );
+    return result.items;
+  }
+  getVibeCodingSessionDebugStatus(sessionId) {
+    return this.client.json("GET", `/api/vibe-coding/sessions/${sessionId}/debug/status`);
+  }
+  getVibeCodingSessionStatus(sessionId) {
+    return this.client.json("GET", `/api/vibe-coding/sessions/${sessionId}/status`);
+  }
+  getVibeCodingDeployStatus(sessionId) {
+    return this.client.json("GET", `/api/vibe-coding/sessions/${sessionId}/deploy/status`);
+  }
+  startVibeCodingService(sessionId) {
+    return this.client.json("POST", `/api/vibe-coding/sessions/${sessionId}/start`);
+  }
+  stopVibeCodingService(sessionId) {
+    return this.client.json("POST", `/api/vibe-coding/sessions/${sessionId}/stop`);
+  }
+  updateVibeCodingDebugService(sessionId) {
+    return this.client.json("POST", `/api/vibe-coding/sessions/${sessionId}/update_debug_service`);
+  }
+  deployVibeCodingSession(sessionId, note, bump = "patch") {
+    const payload = { bump };
+    const normalizedNote = note?.trim();
+    if (normalizedNote) payload.note = normalizedNote;
+    return this.client.json("POST", `/api/vibe-coding/sessions/${sessionId}/deploy`, payload);
+  }
+  async listVibeCodingDeployVersions(sessionId) {
+    const result = await this.client.json(
+      "GET",
+      `/api/vibe-coding/sessions/${sessionId}/deploy/versions`
+    );
+    return result.items;
+  }
+  startVibeCodingDeployService(sessionId, version) {
+    const query = version ? `?version=${encodeURIComponent(version)}` : "";
+    return this.client.json("POST", `/api/vibe-coding/sessions/${sessionId}/deploy/start${query}`);
+  }
+  stopVibeCodingDeployService(sessionId, version) {
+    const query = version ? `?version=${encodeURIComponent(version)}` : "";
+    return this.client.json("POST", `/api/vibe-coding/sessions/${sessionId}/deploy/stop${query}`);
+  }
+  deleteVibeCodingDeployVersion(sessionId, version) {
+    return this.client.json(
+      "DELETE",
+      `/api/vibe-coding/sessions/${sessionId}/deploy/versions/${encodeURIComponent(version)}`
+    );
+  }
+  deleteVibeCodingSession(sessionId) {
+    return this.client.json("DELETE", `/api/vibe-coding/sessions/${sessionId}`);
+  }
+  probeVibeCodingService(sessionId, url) {
+    return this.client.json(
+      "GET",
+      `/api/vibe-coding/sessions/${sessionId}/probe?url=${encodeURIComponent(url)}`
+    );
+  }
+  async exportVibeCodingSession(sessionId) {
+    const res = await this.client.fetch("GET", `/api/vibe-coding/sessions/${sessionId}/export`);
+    const blob = await res.blob();
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = `${sessionId}.zip`;
+    document.body.appendChild(a);
+    a.click();
+    a.remove();
+    URL.revokeObjectURL(url);
+  }
+  async importVibeCodingSession(file, name, codingTemplate) {
+    const form = new FormData();
+    form.append("file", file);
+    if (name) form.append("name", name);
+    if (codingTemplate) form.append("coding_template", codingTemplate);
+    const res = await this.client.formData("POST", "/api/vibe-coding/sessions/import", form);
+    return res.json();
+  }
+};
+
+// src/client/socket.ts
+import { io } from "socket.io-client";
+
+// src/client/auth.ts
+function buildSocketAuth(options) {
+  const token = resolveAuthToken(options);
+  return token ? { token } : void 0;
+}
+function resolveAuthToken(options) {
+  const token = typeof options.token === "function" ? options.token() : options.token;
+  return token ? token : null;
+}
+
+// src/client/socket.ts
+function createSocket(options) {
+  const auth = buildSocketAuth(options);
+  return io(options.baseUrl, {
+    path: options.path ?? "/socket.io",
+    withCredentials: true,
+    auth: typeof options.token === "function" ? (cb) => cb(buildSocketAuth(options) ?? {}) : auth,
+    autoConnect: false
+  });
+}
+
+// src/client/blade-client.ts
+var REFRESH_PATH = "/api/auth/refresh";
+var BladeClient = class {
+  refreshPromise = null;
+  socketInstance = null;
+  storeRestTokenResolver = null;
+  storeSocketTokenResolver = null;
+  options;
+  apiKeys;
+  auth;
+  gis;
+  licenses;
+  memories;
+  models;
+  registry;
+  scenarios;
+  sessions;
+  skills;
+  softwareFactory;
+  solutions;
+  userPreferences;
+  vibeCoding;
+  constructor(options) {
+    this.options = {
+      ...options,
+      baseUrl: normalizeBaseUrl(options.baseUrl)
+    };
+    this.apiKeys = new ApiKeysResource(this);
+    this.auth = new AuthResource(this);
+    this.gis = new GisResource(this);
+    this.licenses = new LicensesResource(this);
+    this.memories = new MemoriesResource(this);
+    this.models = new ModelsResource(this);
+    this.registry = new RegistryResource(this);
+    this.scenarios = new ScenariosResource(this);
+    this.sessions = new SessionsResource(this);
+    this.skills = new SkillsResource(this);
+    this.softwareFactory = new SoftwareFactoryResource(this);
+    this.solutions = new SolutionsResource(this);
+    this.userPreferences = new UserPreferencesResource(this);
+    this.vibeCoding = new VibeCodingResource(this);
+  }
+  _attachStoreRestTokenResolver(fn) {
+    this.storeRestTokenResolver = fn;
+  }
+  _attachStoreSocketTokenResolver(fn) {
+    this.storeSocketTokenResolver = fn;
+  }
+  setBaseUrl(baseUrl) {
+    const nextBaseUrl = normalizeBaseUrl(baseUrl);
+    if (nextBaseUrl === this.options.baseUrl) {
+      return;
+    }
+    this.options.baseUrl = nextBaseUrl;
+    if (this.socketInstance) {
+      this.socketInstance.removeAllListeners();
+      this.socketInstance.disconnect();
+      this.socketInstance = null;
+    }
+  }
+  socket() {
+    if (!this.socketInstance) {
+      this.socketInstance = createSocket({
+        baseUrl: this.options.baseUrl,
+        token: () => this.resolveSocketToken()
+      });
+    }
+    return this.socketInstance;
+  }
+  async json(method, path, body) {
+    const response = await this.fetch(method, path, {
+      body: body === void 0 ? void 0 : JSON.stringify(body),
+      headers: body === void 0 ? void 0 : { "content-type": "application/json" }
+    });
+    return readJsonResponse(response);
+  }
+  async jsonFromInit(path, init = {}) {
+    const method = (init.method ?? "GET").toUpperCase();
+    const headers = new Headers(init.headers);
+    if (init.body != null && !isFormData(init.body) && !headers.has("content-type")) {
+      headers.set("content-type", "application/json");
+    }
+    const response = await this.fetch(method, path, {
+      body: init.body,
+      credentials: init.credentials,
+      headers,
+      signal: init.signal
+    });
+    return readJsonResponse(response);
+  }
+  async text(method, path) {
+    const response = await this.fetch(method, path);
+    return response.text();
+  }
+  async textFromInit(path, init = {}) {
+    const method = (init.method ?? "GET").toUpperCase();
+    const response = await this.fetch(method, path, {
+      body: init.body,
+      credentials: init.credentials,
+      headers: init.headers,
+      signal: init.signal
+    });
+    return response.text();
+  }
+  async responseFromInit(path, init = {}) {
+    const method = (init.method ?? "GET").toUpperCase();
+    return this.fetch(method, path, {
+      body: init.body,
+      credentials: init.credentials,
+      headers: init.headers,
+      signal: init.signal
+    });
+  }
+  async blob(method, path) {
+    const response = await this.fetch(method, path);
+    return response.blob();
+  }
+  async formData(method, path, form, options = {}) {
+    return this.fetch(method, path, { body: form, expectOk: options.expectOk });
+  }
+  async fetch(method, path, init = {}, isRetry = false) {
+    const url = this.buildUrl(path);
+    const response = await (this.options.fetchImpl ?? fetch)(url.toString(), {
+      method,
+      body: init.body,
+      credentials: init.credentials ?? "include",
+      headers: this.buildHeaders(url, init.headers),
+      signal: init.signal
+    });
+    if (response.status === 401 && !isRetry && this.shouldRefreshFor401(url)) {
+      const refreshed = await this.tryRefresh();
+      if (refreshed) {
+        return this.fetch(method, path, init, true);
+      }
+    }
+    if (init.expectOk !== false && !response.ok) {
+      throw new BladeApiError(response);
+    }
+    return response;
+  }
+  buildAuthedUrl(path) {
+    const url = new URL(this.toBaseRelativePath(path), this.baseUrlWithTrailingSlash());
+    const token = this.resolveTokenForUrl(url);
+    if (token) {
+      url.searchParams.set("token", token);
+    }
+    return url.toString();
+  }
+  buildHeaders(url, headers) {
+    const result = new Headers(headers);
+    if (!this.isSameBackendUrl(url)) {
+      return result;
+    }
+    const token = this.resolveRestToken();
+    if (token) {
+      result.set("Authorization", `Bearer ${token}`);
+    }
+    return result;
+  }
+  buildUrl(path) {
+    return new URL(this.toBaseRelativePath(path), this.baseUrlWithTrailingSlash());
+  }
+  baseUrlWithTrailingSlash() {
+    return this.options.baseUrl.endsWith("/") ? this.options.baseUrl : `${this.options.baseUrl}/`;
+  }
+  toBaseRelativePath(path) {
+    return path.startsWith("/") ? path.slice(1) : path;
+  }
+  isSameBackendUrl(url) {
+    const base = new URL(this.baseUrlWithTrailingSlash());
+    if (url.origin !== base.origin) {
+      return false;
+    }
+    const basePath = base.pathname.replace(/\/+$/, "");
+    if (basePath === "") {
+      return true;
+    }
+    return url.pathname === basePath || url.pathname.startsWith(`${basePath}/`);
+  }
+  shouldRefreshFor401(url) {
+    const refreshUrl = this.buildUrl(REFRESH_PATH);
+    return this.isSameBackendUrl(url) && url.pathname !== refreshUrl.pathname && !this.hasExplicitBearerToken();
+  }
+  hasExplicitBearerToken() {
+    return this.options.token !== void 0;
+  }
+  async tryRefresh() {
+    if (this.refreshPromise) {
+      return this.refreshPromise;
+    }
+    this.refreshPromise = (async () => {
+      try {
+        const response = await (this.options.fetchImpl ?? fetch)(
+          this.buildUrl(REFRESH_PATH).toString(),
+          {
+            method: "POST",
+            credentials: "include"
+          }
+        );
+        if (!response.ok) {
+          return false;
+        }
+        await this.options.onRefreshSuccess?.();
+        return true;
+      } catch {
+        return false;
+      } finally {
+        this.refreshPromise = null;
+      }
+    })();
+    return this.refreshPromise;
+  }
+  resolveTokenForUrl(url) {
+    if (!this.isSameBackendUrl(url)) {
+      return null;
+    }
+    return this.resolveRestToken();
+  }
+  resolveRestToken() {
+    return this.resolveToken(this.storeRestTokenResolver);
+  }
+  resolveSocketToken() {
+    return this.resolveToken(this.storeSocketTokenResolver);
+  }
+  resolveToken(resolver) {
+    const token = this.options.token === void 0 ? resolver?.() : typeof this.options.token === "function" ? this.options.token() : this.options.token;
+    return token ? token : null;
+  }
+};
+function normalizeBaseUrl(baseUrl) {
+  const normalized = baseUrl.trim().replace(/\/+$/, "");
+  if (normalized || typeof window === "undefined") {
+    return normalized;
+  }
+  return window.location.origin;
+}
+function isFormData(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+function readJsonResponse(response) {
+  if (response.status === 204 || response.headers.get("content-length") === "0") {
+    return Promise.resolve(void 0);
+  }
+  return response.json();
+}
+export {
+  ApiKeysResource,
+  AuthResource,
+  BladeApiError,
+  BladeClient,
+  GisResource,
+  LicensesResource,
+  MemoriesResource,
+  ModelOption,
+  ModelsConfig,
+  ModelsResource,
+  REGISTRY_PREFIX,
+  RegistryResource,
+  ScenariosResource,
+  SessionsResource,
+  SkillsResource,
+  SoftwareFactoryResource,
+  SolutionsResource,
+  UserPreferencesResource,
+  VibeCodingResource,
+  createSocket,
+  normalizeResource
+};
+//# sourceMappingURL=index.js.map