@keboola/api-client 20.0.0 → 23.0.0

package/dist/index.cjs

@@ -1,269 +1,63 @@
 'use strict';
 
+var chunkZ76DIRLA_cjs = require('./chunk-Z76DIRLA.cjs');
+var chunkGF4XZK5N_cjs = require('./chunk-GF4XZK5N.cjs');
 var chunkUUY6LQT6_cjs = require('./chunk-UUY6LQT6.cjs');
 var chunk3FZHFTLG_cjs = require('./chunk-3FZHFTLG.cjs');
-var chunkIWIN6HKU_cjs = require('./chunk-IWIN6HKU.cjs');
-var chunkBR3SBEFE_cjs = require('./chunk-BR3SBEFE.cjs');
-var chunkAWRMGLMT_cjs = require('./chunk-AWRMGLMT.cjs');
-var chunkUFQVOZZ6_cjs = require('./chunk-UFQVOZZ6.cjs');
-require('./chunk-TTPJSPZA.cjs');
-var chunkGF4XZK5N_cjs = require('./chunk-GF4XZK5N.cjs');
-var chunk4JCVPUXF_cjs = require('./chunk-4JCVPUXF.cjs');
-var chunkCVV4HROS_cjs = require('./chunk-CVV4HROS.cjs');
-var chunkEKWD4ODT_cjs = require('./chunk-EKWD4ODT.cjs');
-var chunkSTAQJVW4_cjs = require('./chunk-STAQJVW4.cjs');
-var chunkXISA4SYM_cjs = require('./chunk-XISA4SYM.cjs');
-var chunkANRUSNYD_cjs = require('./chunk-ANRUSNYD.cjs');
+require('./chunk-3KEVPUSX.cjs');
+var chunkEYIPM2XB_cjs = require('./chunk-EYIPM2XB.cjs');
+var chunkFRLSKIUI_cjs = require('./chunk-FRLSKIUI.cjs');
+var chunkKUYVBCUM_cjs = require('./chunk-KUYVBCUM.cjs');
+var chunkEWMXK3EI_cjs = require('./chunk-EWMXK3EI.cjs');
+var chunk35MODDCL_cjs = require('./chunk-35MODDCL.cjs');
+var chunkHZSZQFEO_cjs = require('./chunk-HZSZQFEO.cjs');
+var chunkKY4EYQ6I_cjs = require('./chunk-KY4EYQ6I.cjs');
+var chunkQ7C2IRF2_cjs = require('./chunk-Q7C2IRF2.cjs');
+var chunk5ZOWA7DA_cjs = require('./chunk-5ZOWA7DA.cjs');
+var chunkK6EZ3USU_cjs = require('./chunk-K6EZ3USU.cjs');
 var chunkRRC5RKF7_cjs = require('./chunk-RRC5RKF7.cjs');
-var chunkMLCMKHMK_cjs = require('./chunk-MLCMKHMK.cjs');
-var chunkSWJHENEP_cjs = require('./chunk-SWJHENEP.cjs');
-var chunkWWICQYOY_cjs = require('./chunk-WWICQYOY.cjs');
-var chunkZLW3243Q_cjs = require('./chunk-ZLW3243Q.cjs');
-var chunkIZWNTRMT_cjs = require('./chunk-IZWNTRMT.cjs');
-var chunkQQJXXNUE_cjs = require('./chunk-QQJXXNUE.cjs');
-var chunkG7VCXMQB_cjs = require('./chunk-G7VCXMQB.cjs');
-var chunkYLHZ2H7O_cjs = require('./chunk-YLHZ2H7O.cjs');
-var chunkYOPRPXER_cjs = require('./chunk-YOPRPXER.cjs');
-var chunkJJXTE2SL_cjs = require('./chunk-JJXTE2SL.cjs');
-var chunkN3GNUFMA_cjs = require('./chunk-N3GNUFMA.cjs');
-var chunkJIAMBOU7_cjs = require('./chunk-JIAMBOU7.cjs');
+var chunkVPNWX7YM_cjs = require('./chunk-VPNWX7YM.cjs');
+var chunk22D55AHX_cjs = require('./chunk-22D55AHX.cjs');
+var chunkIYGHWPCR_cjs = require('./chunk-IYGHWPCR.cjs');
+var chunkCN5GAKRO_cjs = require('./chunk-CN5GAKRO.cjs');
+var chunk4GUUSO5O_cjs = require('./chunk-4GUUSO5O.cjs');
+var chunkFDTWXXI4_cjs = require('./chunk-FDTWXXI4.cjs');
+var chunkT7SEZMQ7_cjs = require('./chunk-T7SEZMQ7.cjs');
+var chunkFMS5PNM2_cjs = require('./chunk-FMS5PNM2.cjs');
+var chunkWZGBE4XH_cjs = require('./chunk-WZGBE4XH.cjs');
+var chunkX4HEWMPU_cjs = require('./chunk-X4HEWMPU.cjs');
+require('./chunk-QHD4LPAQ.cjs');
+var chunk556U6PFA_cjs = require('./chunk-556U6PFA.cjs');
+var chunkYEF46DYF_cjs = require('./chunk-YEF46DYF.cjs');
+var chunkFVJC2GJY_cjs = require('./chunk-FVJC2GJY.cjs');
 require('./chunk-U5SE6W5M.cjs');
-var chunk4H2DDEUI_cjs = require('./chunk-4H2DDEUI.cjs');
+var chunkBWBTNAVL_cjs = require('./chunk-BWBTNAVL.cjs');
 var chunkMRHQJNWF_cjs = require('./chunk-MRHQJNWF.cjs');
-var chunkAKDJSXVJ_cjs = require('./chunk-AKDJSXVJ.cjs');
-var chunkHNP33VR5_cjs = require('./chunk-HNP33VR5.cjs');
-var chunkNRJTA5P3_cjs = require('./chunk-NRJTA5P3.cjs');
-var chunkIUN2ZSU3_cjs = require('./chunk-IUN2ZSU3.cjs');
-var zod = require('zod');
+var chunkYQEBJG5H_cjs = require('./chunk-YQEBJG5H.cjs');
+var chunk43CGBOVT_cjs = require('./chunk-43CGBOVT.cjs');
+var chunkCCC6I32C_cjs = require('./chunk-CCC6I32C.cjs');
+var chunkDMNWPVVT_cjs = require('./chunk-DMNWPVVT.cjs');
+var z2 = require('zod');
 
-var agentSettingsSchema = zod.z.object({
-  projectId: zod.z.string(),
-  customInstructions: zod.z.string().nullable(),
-  createdAt: zod.z.string(),
-  updatedAt: zod.z.string()
-});
-var toolPermissionValueSchema = zod.z.enum(["always_allow", "always_ask", "blocked"]);
-var userAgentSettingsSchema = zod.z.object({
-  projectId: zod.z.string(),
-  userId: zod.z.string(),
-  customInstructions: zod.z.string().nullable(),
-  toolPermissions: zod.z.record(zod.z.string(), toolPermissionValueSchema).nullable(),
-  createdAt: zod.z.string(),
-  updatedAt: zod.z.string()
-});
-var toolInfoSchema = zod.z.object({
-  name: zod.z.string(),
-  description: zod.z.string(),
-  readOnly: zod.z.boolean()
-});
-var toolsListResponseSchema = zod.z.object({
-  tools: zod.z.array(toolInfoSchema)
-});
-var skillInfoSchema = zod.z.object({
-  name: zod.z.string(),
-  description: zod.z.string().nullable(),
-  source: zod.z.enum(["first-party", "vendored", "project"])
-});
-var builtInCommandSchema = zod.z.object({
-  name: zod.z.string(),
-  description: zod.z.string()
-});
-var skillsListResponseSchema = zod.z.object({
-  skills: zod.z.array(skillInfoSchema),
-  commands: zod.z.array(builtInCommandSchema)
-});
-var sandboxFileEntrySchema = zod.z.object({
-  name: zod.z.string(),
-  path: zod.z.string(),
-  type: zod.z.enum(["file", "dir"]),
-  size: zod.z.number().int().nonnegative().optional()
-});
-var sandboxFileListingSchema = zod.z.object({
-  entries: zod.z.array(sandboxFileEntrySchema)
-});
-var sandboxFileContentSchema = zod.z.object({
-  content: zod.z.string(),
-  encoding: zod.z.enum(["utf-8", "binary"]),
-  truncated: zod.z.boolean(),
-  size: zod.z.number().int().nonnegative()
-});
-var sandboxGitBranchSchema = zod.z.object({
-  branch: zod.z.string().nullable()
-});
-var createKaiAgentClient = ({ baseUrl, middlewares, auth }) => {
-  const clientOptions = {
-    baseUrl,
-    middlewares,
-    headers: chunkHNP33VR5_cjs.createAuthHeaders(auth)
-  };
-  const client = chunkIUN2ZSU3_cjs.createOpenapiFetchClient(clientOptions);
-  const genericClient = chunkIUN2ZSU3_cjs.createGenericFetchClient(clientOptions);
-  const getHistory = async (params) => {
-    const { data } = await client.get("/api/history", { query: params });
-    return data;
-  };
-  const getChat = async (chatId, signal) => {
-    const { data } = await client.get("/api/chat/{id}", { path: { id: chatId } }, { signal });
-    return data;
-  };
-  const deleteChat = async (chatId) => {
-    const { data } = await client.delete("/api/chat", { query: { id: chatId } });
-    return data;
-  };
-  const createChat = async (request) => {
-    const { response } = await client.post("/api/chat", { body: request });
-    return response;
-  };
-  const getVotes = async (chatId) => {
-    const { data } = await client.get("/api/vote", { query: { chatId } });
-    return data;
-  };
-  const submitVote = async (params) => {
-    await client.patch("/api/vote", { body: params });
-  };
-  const getUsage = async (signal) => {
-    const { data } = await client.get("/api/usage", {}, { signal });
-    return data;
-  };
-  const approveToolCall = async (chatId, body) => {
-    await client.post("/api/chat/{id}/approval", { path: { id: chatId }, body });
-  };
-  const submitToolOutput = async (chatId, body) => {
-    await client.post("/api/chat/{id}/ui-tool-result", { path: { id: chatId }, body });
-  };
-  const stopChat = async (chatId) => {
-    const { data } = await client.post("/api/chat/{id}/stop", { path: { id: chatId } });
-    return data;
-  };
-  const getSuggestions = async (request, signal) => {
-    const { data } = await client.post("/api/suggestions", { body: request }, { signal });
-    return data;
-  };
-  const getAgentSettings = async (signal) => {
-    const { data } = await genericClient.get("/api/settings", {}, { signal });
-    const result = agentSettingsSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid agent settings response format");
-    }
-    return result.data;
-  };
-  const updateAgentSettings = async (request, signal) => {
-    const { data } = await genericClient.patch(
-      "/api/settings",
-      { body: request },
-      { signal }
-    );
-    const result = agentSettingsSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid agent settings response format");
-    }
-    return result.data;
-  };
-  const getUserAgentSettings = async (signal) => {
-    const { data } = await genericClient.get(
-      "/api/settings/user",
-      {},
-      { signal }
-    );
-    const result = userAgentSettingsSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid user agent settings response format");
-    }
-    return result.data;
-  };
-  const updateUserAgentSettings = async (request, signal) => {
-    const { data } = await genericClient.patch(
-      "/api/settings/user",
-      { body: request },
-      { signal }
-    );
-    const result = userAgentSettingsSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid user agent settings response format");
-    }
-    return result.data;
-  };
-  const getToolsList = async (signal) => {
-    const { data } = await genericClient.get(
-      "/api/settings/tools",
-      {},
-      { signal }
-    );
-    const result = toolsListResponseSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid tools list response format");
-    }
-    return result.data;
-  };
-  const getSkillsList = async (signal) => {
-    const { data } = await genericClient.get("/api/skills", {}, { signal });
-    const result = skillsListResponseSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid skills list response format");
-    }
-    return result.data;
-  };
-  const listSandboxFiles = async (chatId, path, signal) => {
-    const { data } = await genericClient.get(
-      `/api/chat/${encodeURIComponent(chatId)}/sandbox/files`,
-      { query: path ? { path } : void 0 },
-      { signal }
-    );
-    const result = sandboxFileListingSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid sandbox files response format");
-    }
-    return result.data;
-  };
-  const readSandboxFile = async (chatId, path, signal) => {
-    const { data } = await genericClient.get(
-      `/api/chat/${encodeURIComponent(chatId)}/sandbox/file`,
-      { query: { path } },
-      { signal }
-    );
-    const result = sandboxFileContentSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid sandbox file response format");
-    }
-    return result.data;
-  };
-  const getSandboxGitBranch = async (chatId, signal) => {
-    const { data } = await genericClient.get(
-      `/api/chat/${encodeURIComponent(chatId)}/sandbox/git-branch`,
-      {},
-      { signal }
-    );
-    const result = sandboxGitBranchSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid sandbox git-branch response format");
-    }
-    return result.data;
-  };
-  const chatStreamUrl = clientOptions.baseUrl + "/api/chat";
-  return {
-    getHistory,
-    getChat,
-    deleteChat,
-    createChat,
-    getVotes,
-    submitVote,
-    getUsage,
-    approveToolCall,
-    submitToolOutput,
-    stopChat,
-    getSuggestions,
-    getAgentSettings,
-    updateAgentSettings,
-    getUserAgentSettings,
-    updateUserAgentSettings,
-    getToolsList,
-    getSkillsList,
-    listSandboxFiles,
-    readSandboxFile,
-    getSandboxGitBranch,
-    chatStreamUrl
-  };
-};
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var z2__namespace = /*#__PURE__*/_interopNamespace(z2);
 
 // src/utils/assert.ts
 function assert(value, message) {
@@ -272,7 +66,7 @@ function assert(value, message) {
   }
 }
 
-// src/utils/coalesce.ts
+// src/utils/async/coalesce.ts
 var coalesce = (task) => {
   let running = false;
   const waiters = [];
@@ -312,6 +106,10 @@ var createStore = (initial) => {
       return () => {
         listeners.delete(listener);
       };
+    },
+    dispose: () => {
+      value = initial;
+      listeners.clear();
     }
   };
 };
@@ -336,13 +134,84 @@ var createDerivedStore = ({
 }) => {
   let key = dependsOn(source.get());
   const store = createStore(build(key));
-  source.subscribe((state) => {
+  const unsubscribe = source.subscribe((state) => {
     const next = dependsOn(state);
     if (keyEquals(key, next)) return;
     key = next;
     store.set(build(next));
   });
-  return { get: store.get, subscribe: store.subscribe };
+  return {
+    get: store.get,
+    subscribe: store.subscribe,
+    dispose: () => {
+      unsubscribe();
+      store.dispose();
+    }
+  };
+};
+var createDerivedAsyncStore = ({
+  source,
+  dependsOn,
+  build,
+  keyEquals = shallowEqual
+}) => {
+  const store = createStore({ state: "idle" });
+  let currentKey = null;
+  let generation = 0;
+  let controller = null;
+  const run = (key) => {
+    controller?.abort();
+    controller = new AbortController();
+    const runGeneration = ++generation;
+    store.set({ state: "pending" });
+    build(key, controller.signal).then(
+      (value) => {
+        if (runGeneration === generation) store.set({ state: "ready", value });
+      },
+      (error) => {
+        if (runGeneration === generation) store.set({ state: "errored", error });
+      }
+    );
+  };
+  const sync = (state) => {
+    const next = dependsOn(state);
+    if (next === null) {
+      if (currentKey === null) return;
+      controller?.abort();
+      controller = null;
+      generation += 1;
+      currentKey = null;
+      store.set({ state: "idle" });
+      return;
+    }
+    if (currentKey !== null && keyEquals(currentKey, next)) return;
+    currentKey = next;
+    run(next);
+  };
+  sync(source.get());
+  const unsubscribe = source.subscribe(sync);
+  const readable = {
+    get: store.get,
+    subscribe: store.subscribe,
+    dispose: () => {
+      controller?.abort();
+      unsubscribe();
+      store.dispose();
+    }
+  };
+  const settled = () => new Promise((resolve) => {
+    let unsubscribeSettled = () => {
+    };
+    const check = (state) => {
+      if (state.state === "ready" || state.state === "errored") {
+        unsubscribeSettled();
+        resolve(state);
+      }
+    };
+    unsubscribeSettled = store.subscribe(check);
+    check(store.get());
+  });
+  return { store: readable, settled };
 };
 
 // src/utils/deepMerge.ts
@@ -356,28 +225,557 @@ var deepMerge = (base, patch) => {
   return out;
 };
 
-// src/domain/defaultBranch.ts
-var createDefaultBranch = ({ devBranches }) => {
-  const defaultBranch = devBranches.find((branch) => branch.isDefault);
-  assert(defaultBranch, "No default branch found for the project.");
-  const getType = (branchId) => {
-    if (branchId == null || branchId === "default") return "default";
-    return Number(branchId) === defaultBranch.id ? "default" : "dev";
+// src/utils/persistor/adapters.ts
+var createNullStorage = () => ({
+  getItem: () => null,
+  setItem: () => {
+  },
+  removeItem: () => {
+  }
+});
+var createMemoryStorage = () => {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    getItem: (key) => store.get(key) ?? null,
+    setItem: (key, value) => {
+      store.set(key, value);
+    },
+    removeItem: (key) => {
+      store.delete(key);
+    }
   };
+};
+var createWebStorage = (pick) => {
+  let web = null;
+  try {
+    web = pick();
+    if (web) {
+      const probe = "__keboola_storage_probe__";
+      web.setItem(probe, probe);
+      web.removeItem(probe);
+    }
+  } catch (err) {
+    console.warn("createWebStorage: web storage unavailable, falling back to memory", err);
+    web = null;
+  }
+  if (!web) return createMemoryStorage();
+  const storage = web;
   return {
-    id: defaultBranch.id,
-    name: defaultBranch.name,
-    getType,
-    isDev: (branchId) => getType(branchId) === "dev",
-    isDefault: (branchId) => getType(branchId) === "default"
+    getItem: (key) => storage.getItem(key),
+    setItem: (key, value) => {
+      storage.setItem(key, value);
+    },
+    removeItem: (key) => {
+      storage.removeItem(key);
+    }
   };
 };
+var createLocalStorage = () => createWebStorage(() => "localStorage" in globalThis ? globalThis.localStorage : null);
+var createSessionStorage = () => createWebStorage(() => "sessionStorage" in globalThis ? globalThis.sessionStorage : null);
 
-// src/domain/stack.ts
-var SERVICE_URL_OVERRIDES = {
-  // The service URL for the Kai Assistant is incomplete; we need to add the `/api` suffix to get the full URL for the API.
-  // I assume the service is versioned.
-  "kai-assistant": (url) => `${url}/api`
+// src/utils/persistor/persistor.ts
+var createPersistor = ({
+  storage = createNullStorage(),
+  key,
+  schema,
+  defaultValue,
+  encode = JSON.stringify,
+  decode = JSON.parse
+}) => {
+  const clear = () => {
+    try {
+      storage.removeItem(key);
+    } catch (err) {
+      console.warn(`createPersistor: failed to clear "${key}"`, err);
+    }
+  };
+  const hasPersistedValue = () => {
+    try {
+      return !!storage.getItem(key);
+    } catch (err) {
+      console.warn(`createPersistor: failed to read "${key}", assuming empty`, err);
+      return false;
+    }
+  };
+  const hydrate = () => {
+    let raw;
+    try {
+      raw = storage.getItem(key);
+    } catch (err) {
+      console.warn(`createPersistor: failed to read "${key}", using default`, err);
+      return defaultValue;
+    }
+    if (raw === null) return defaultValue;
+    let decoded;
+    try {
+      decoded = decode(raw);
+    } catch (err) {
+      console.warn(`createPersistor: failed to decode "${key}", resetting`, err);
+      clear();
+      return defaultValue;
+    }
+    const parsed = schema.safeParse(decoded);
+    if (parsed.success) return parsed.data;
+    clear();
+    return defaultValue;
+  };
+  const persist = (value) => {
+    let raw;
+    try {
+      raw = encode(value);
+    } catch (err) {
+      console.warn(`createPersistor: failed to encode "${key}", not persisting`, err);
+      return;
+    }
+    try {
+      storage.setItem(key, raw);
+    } catch (err) {
+      console.warn(`createPersistor: failed to write "${key}"`, err);
+    }
+  };
+  return { hydrate, persist, clear, hasPersistedValue };
+};
+
+// src/keboola/createLiveProject.ts
+var STORAGE_TOKEN_MUTATING_PATTERNS = [
+  // Bucket lifecycle (create / delete / register) — changes token.bucketPermissions.
+  // At most one trailing segment, so sub-resources (tables, listing, metadata, refresh)
+  // under /buckets/{id}/... don't trigger a re-verify.
+  /\/buckets(\/[^/]+)?$/,
+  // Project feature toggles — changes token.owner.features. Anchored to
+  // /projects/{id}/features so /manage/features and /users/{id}/features don't match.
+  /\/projects\/[^/]+\/features(\/[^/]+)?$/
+];
+var isStorageTokenMutatingRequest = (request) => {
+  if (request.method === "GET") return false;
+  const { pathname } = new URL(request.url);
+  return STORAGE_TOKEN_MUTATING_PATTERNS.some((pattern) => pattern.test(pathname));
+};
+var createProjectRefreshMiddleware = (shouldRefresh, requestRefresh) => (next) => async (request) => {
+  const response = await next(request);
+  if (shouldRefresh(request.request)) await requestRefresh();
+  return response;
+};
+var createLiveProject = ({
+  initialToken,
+  verify
+}) => {
+  const store = createStore(chunkGF4XZK5N_cjs.createProject({ sapiToken: initialToken }));
+  const refresh = coalesce(async () => store.set(chunkGF4XZK5N_cjs.createProject({ sapiToken: await verify() })));
+  const middleware = createProjectRefreshMiddleware(isStorageTokenMutatingRequest, refresh);
+  return { store, getProject: () => store.get(), subscribe: store.subscribe, middleware, refresh };
+};
+
+// src/keboola/errors.ts
+var KeboolaErrorType = {
+  Unconfigured: "unconfigured",
+  NotAuthenticated: "not-authenticated",
+  AlreadyAuthenticated: "already-authenticated",
+  NoStorageToken: "no-storage-token",
+  NoManagementToken: "no-management-token",
+  MissingProject: "missing-project",
+  NotBearer: "not-bearer",
+  NotReady: "not-ready",
+  InvalidBuildTransition: "invalid-build-transition"
+};
+var MESSAGES = {
+  [KeboolaErrorType.Unconfigured]: "The session is not configured \u2014 set a baseUrl first.",
+  [KeboolaErrorType.NotAuthenticated]: "The session is not authenticated \u2014 sign in first.",
+  [KeboolaErrorType.AlreadyAuthenticated]: "The session is already authenticated \u2014 reset before authenticating again.",
+  [KeboolaErrorType.NoStorageToken]: "No storage token \u2014 authenticate the storage realm first.",
+  [KeboolaErrorType.NoManagementToken]: "No management token \u2014 authenticate the management realm first.",
+  [KeboolaErrorType.MissingProject]: "A bearer storage session requires a project \u2014 call setProject(projectId) first.",
+  [KeboolaErrorType.NotBearer]: "This operation requires a bearer (OAuth) session.",
+  [KeboolaErrorType.NotReady]: "The client is not ready \u2014 authenticate the storage realm first.",
+  [KeboolaErrorType.InvalidBuildTransition]: "Invalid storage build transition \u2014 the build goes idle \u2192 initializing \u2192 ready | failed."
+};
+var KeboolaError = class _KeboolaError extends Error {
+  type;
+  constructor(type) {
+    super(MESSAGES[type]);
+    this.type = type;
+    this.name = "KeboolaError";
+    Object.setPrototypeOf(this, _KeboolaError.prototype);
+  }
+};
+var isKeboolaError = (error) => error instanceof KeboolaError;
+function assert2(value, type) {
+  if (value == null) throw new KeboolaError(type);
+}
+
+// src/middlewares/loggingMiddleware.ts
+var CORRELATION_ID_HEADER = "X-Correlation-ID";
+var ALWAYS_REDACTED_HEADERS = [
+  chunkDMNWPVVT_cjs.KeboolaHttpHeader.MANAGEMENT_API_TOKEN,
+  chunkDMNWPVVT_cjs.KeboolaHttpHeader.STORAGE_API_TOKEN,
+  "authorization",
+  "cookie",
+  "set-cookie"
+];
+var ALWAYS_REDACTED_QUERY_PARAMS = /* @__PURE__ */ new Set([
+  "token",
+  "apikey",
+  "api_key",
+  "access_token",
+  "refresh_token",
+  "code",
+  "state",
+  "signature",
+  "sig",
+  "x-amz-signature",
+  "x-amz-credential",
+  "x-amz-security-token",
+  "password",
+  "secret"
+]);
+var REDACTED = "[REDACTED]";
+var getRedactedUrl = (rawUrl) => {
+  const url = new URL(rawUrl);
+  if (url.username) url.username = REDACTED;
+  if (url.password) url.password = REDACTED;
+  url.searchParams.forEach((_value, key) => {
+    if (ALWAYS_REDACTED_QUERY_PARAMS.has(key.toLowerCase())) {
+      url.searchParams.set(key, REDACTED);
+    }
+  });
+  return url.toString();
+};
+var ensureCorrelationId = (request) => {
+  const correlationId = request.headers.get(CORRELATION_ID_HEADER) ?? chunkEWMXK3EI_cjs.generateUUID();
+  request.headers.set(CORRELATION_ID_HEADER, correlationId);
+  return correlationId;
+};
+var getRedactedHeaders = (headers, redacted) => {
+  const redactedSet = new Set(
+    [...ALWAYS_REDACTED_HEADERS, ...redacted].map((h) => h.toLowerCase())
+  );
+  const result = {};
+  headers.forEach((value, name) => {
+    result[name] = redactedSet.has(name.toLowerCase()) ? REDACTED : value;
+  });
+  return result;
+};
+var getRequestLog = (request, redactedHeaders) => ({
+  url: getRedactedUrl(request.url),
+  headers: getRedactedHeaders(request.headers, redactedHeaders)
+});
+var getResponseLog = (response, redactedHeaders) => ({
+  status: response.status,
+  statusText: response.statusText,
+  headers: getRedactedHeaders(response.headers, redactedHeaders)
+});
+var redactApiError = (error, redactedHeaders) => new chunkDMNWPVVT_cjs.ApiError({
+  request: new Request(getRedactedUrl(error.request.url), {
+    method: error.request.method,
+    headers: getRedactedHeaders(error.request.headers, redactedHeaders)
+  }),
+  response: new Response(null, {
+    status: error.response.status,
+    statusText: error.response.statusText,
+    headers: getRedactedHeaders(error.response.headers, redactedHeaders)
+  }),
+  data: error.data
+});
+var formatLog = (level, log) => {
+  const parts = [`[${level.toUpperCase()}]`, `${Math.round(log.durationMs)}ms`, log.method];
+  parts.push(log.request.url);
+  if ("response" in log) parts.push(String(log.response.status));
+  return parts.join(" ");
+};
+var createSafeLogger = (logger, level = "error-only") => {
+  return {
+    info: (log) => {
+      if (level !== "all") return;
+      try {
+        if (logger?.info) {
+          logger.info(log);
+          return;
+        }
+        console.info(formatLog("info", log));
+      } catch {
+      }
+    },
+    error: (log) => {
+      try {
+        if (logger?.error) {
+          logger.error(log);
+          return;
+        }
+        console.error(formatLog("error", log));
+      } catch {
+      }
+    }
+  };
+};
+var createLoggingMiddleware = (options = {}) => {
+  const safeLogger = createSafeLogger(options.logger, options.level);
+  const redactHeaders = options.redactHeaders ?? [];
+  return (next) => async (fetchRequest) => {
+    const correlationId = ensureCorrelationId(fetchRequest.request);
+    const start = performance.now();
+    const method = fetchRequest.request.method.toLowerCase();
+    const requestLog = getRequestLog(fetchRequest.request, redactHeaders);
+    try {
+      const result = await next(fetchRequest);
+      safeLogger.info({
+        correlationId,
+        method,
+        durationMs: performance.now() - start,
+        request: requestLog,
+        response: getResponseLog(result.response, redactHeaders)
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof Error)
+        safeLogger.error({
+          correlationId,
+          method,
+          durationMs: performance.now() - start,
+          request: requestLog,
+          error: chunkDMNWPVVT_cjs.isApiError(error) ? redactApiError(error, redactHeaders) : error
+        });
+      throw error;
+    }
+  };
+};
+
+// src/middlewares/retryMiddleware.ts
+var DEFAULT_MAX_RETRIES = 5;
+var DEFAULT_RETRYABLE_STATUSES = [
+  chunkDMNWPVVT_cjs.HttpStatus.INTERNAL_SERVER_ERROR,
+  chunkDMNWPVVT_cjs.HttpStatus.BAD_GATEWAY,
+  chunkDMNWPVVT_cjs.HttpStatus.SERVICE_UNAVAILABLE,
+  chunkDMNWPVVT_cjs.HttpStatus.GATEWAY_TIMEOUT
+];
+var DEFAULT_BACKOFF_FACTOR = 0.3;
+var defaultShouldRetry = (error) => error instanceof chunkDMNWPVVT_cjs.ApiError && DEFAULT_RETRYABLE_STATUSES.includes(error.response.status);
+var createRetryMiddleware = (options) => {
+  const {
+    maxRetries = DEFAULT_MAX_RETRIES,
+    backoffFactor = DEFAULT_BACKOFF_FACTOR,
+    shouldRetry = defaultShouldRetry
+  } = options ?? {};
+  if (!Number.isInteger(maxRetries) || maxRetries < 0) {
+    throw new RangeError("maxRetries must be a non-negative integer");
+  }
+  if (!Number.isFinite(backoffFactor) || backoffFactor < 0) {
+    throw new RangeError("backoffFactor must be a finite non-negative number");
+  }
+  return (next) => async (request) => {
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await next({ ...request, request: request.request.clone() });
+      } catch (error) {
+        if (attempt === maxRetries || !shouldRetry(error, attempt)) {
+          throw error;
+        }
+        const delayMs = backoffFactor * 1e3 * Math.pow(2, attempt);
+        await chunk35MODDCL_cjs.delay(delayMs, request.request.signal ?? void 0);
+      }
+    }
+    throw new Error("unreachable");
+  };
+};
+
+// src/serviceClientRegistry/utils.ts
+var isBuiltInProperty = (property) => typeof property === "symbol" || property === "then" || property === "constructor" || property === "toString" || property === "valueOf";
+var createDummyClient = ({
+  onCall
+}) => {
+  const createProxy = (path = []) => new Proxy(() => {
+  }, {
+    // Create a new proxy for nested property access
+    get: (_target, prop) => {
+      if (isBuiltInProperty(prop)) return void 0;
+      return createProxy([...path, prop]);
+    },
+    // When called as a function, invoke the interceptor
+    apply: (_target, _thisArgs, args) => onCall(path, args)
+  });
+  return createProxy();
+};
+
+// src/serviceClientRegistry/createServiceClientRegistry.ts
+var createServiceClientRegistry = () => ({
+  getServiceBaseUrl,
+  onUnavailable
+}) => {
+  const dummy = (serviceId, clientName) => createDummyClient({
+    onCall: (path, args) => {
+      onUnavailable?.({
+        serviceId,
+        path,
+        args,
+        clientName
+      });
+    }
+  });
+  const configs = [];
+  const resolveClient = ({
+    serviceId,
+    clientFn,
+    clientName
+  }) => {
+    const serviceBaseUrl = getServiceBaseUrl(serviceId);
+    return serviceBaseUrl ? clientFn(serviceBaseUrl) : dummy(serviceId, clientName);
+  };
+  const registry = {
+    add: (config) => {
+      configs.push(config);
+      return registry;
+    },
+    build: () => {
+      const clientMap = {};
+      const clientMeta = [];
+      configs.forEach((config) => {
+        clientMap[config.clientName] = resolveClient(config);
+        clientMeta.push({
+          clientName: config.clientName,
+          serviceId: config.serviceId,
+          isAvailable: !!getServiceBaseUrl(config.serviceId)
+        });
+      });
+      return {
+        client: clientMap,
+        meta: clientMeta
+      };
+    }
+  };
+  return registry;
+};
+
+// src/keboola/createApi.ts
+var createApi = (state) => new Proxy({}, {
+  get(_target, property) {
+    if (isBuiltInProperty(property)) return void 0;
+    if (property === "auth") {
+      const authClient = state.getAuthClient();
+      assert2(authClient, KeboolaErrorType.Unconfigured);
+      return authClient;
+    }
+    if (property === "management") {
+      const management = state.getManagementClient();
+      assert2(management, KeboolaErrorType.NoManagementToken);
+      return management;
+    }
+    const clients = state.getProjectClients();
+    assert2(clients, KeboolaErrorType.NotReady);
+    return clients[property];
+  }
+});
+
+// src/keboola/createMiddlewareFor.ts
+var createMiddlewareFor = (middlewares) => {
+  return (target, baseline = []) => {
+    if (Array.isArray(middlewares)) return [...baseline, ...middlewares];
+    const all = middlewares?.all ?? [];
+    const targeted = middlewares?.[target] ?? [];
+    return [...baseline, ...all, ...targeted];
+  };
+};
+
+// src/keboola/bearer/createConfig.ts
+var INITIAL = { status: "anonymous", baseUrl: null };
+var stamp = (tokens) => ({ ...tokens, issuedAt: Date.now() });
+var createConfig = (initial = INITIAL) => {
+  const store = createStore(initial);
+  let expiredNotified = false;
+  const setBaseUrl = (baseUrl) => {
+    if (store.get().status !== "anonymous")
+      throw new KeboolaError(KeboolaErrorType.AlreadyAuthenticated);
+    store.set({ status: "anonymous", baseUrl });
+  };
+  const authenticate = (tokens) => {
+    const state = store.get();
+    if (state.status !== "anonymous") throw new KeboolaError(KeboolaErrorType.AlreadyAuthenticated);
+    if (!state.baseUrl) throw new KeboolaError(KeboolaErrorType.Unconfigured);
+    expiredNotified = false;
+    store.set({ status: "authenticated", baseUrl: state.baseUrl, credential: stamp(tokens) });
+  };
+  const setProjectId = (projectId) => {
+    const state = store.get();
+    if (state.status === "anonymous") throw new KeboolaError(KeboolaErrorType.NotAuthenticated);
+    store.set({
+      status: "scoped",
+      baseUrl: state.baseUrl,
+      credential: state.credential,
+      projectId
+    });
+  };
+  const clearProjectId = () => {
+    const state = store.get();
+    if (state.status !== "scoped") return;
+    store.set({ status: "authenticated", baseUrl: state.baseUrl, credential: state.credential });
+  };
+  const reset = () => {
+    store.set({ status: "anonymous", baseUrl: store.get().baseUrl });
+  };
+  const applyRefresh = (tokens) => {
+    const state = store.get();
+    if (state.status === "anonymous") return;
+    store.set({ ...state, credential: stamp(tokens) });
+  };
+  const forceExpire = () => {
+    const state = store.get();
+    if (state.status === "anonymous") return;
+    const issuedAt = Date.now() - state.credential.expiresIn * 1e3;
+    store.set({ ...state, credential: { ...state.credential, issuedAt } });
+  };
+  const requireCredential = () => {
+    const state = store.get();
+    if (state.status === "anonymous") throw new KeboolaError(KeboolaErrorType.NotAuthenticated);
+    return state.credential;
+  };
+  const getBaseUrl = () => store.get().baseUrl;
+  const notifyExpired = () => {
+    if (expiredNotified) return false;
+    expiredNotified = true;
+    return true;
+  };
+  const debug = () => store.get();
+  const readable = {
+    get: store.get,
+    subscribe: store.subscribe,
+    dispose: store.dispose
+  };
+  return {
+    store: readable,
+    setBaseUrl,
+    authenticate,
+    setProjectId,
+    clearProjectId,
+    reset,
+    applyRefresh,
+    forceExpire,
+    requireCredential,
+    getBaseUrl,
+    notifyExpired,
+    debug
+  };
+};
+
+// src/domain/defaultBranch.ts
+var createDefaultBranch = ({ devBranches }) => {
+  const defaultBranch = devBranches.find((branch) => branch.isDefault);
+  assert(defaultBranch, "No default branch found for the project.");
+  const getType = (branchId) => {
+    if (branchId == null || branchId === "default") return "default";
+    return Number(branchId) === defaultBranch.id ? "default" : "dev";
+  };
+  return {
+    id: defaultBranch.id,
+    name: defaultBranch.name,
+    getType,
+    isDev: (branchId) => getType(branchId) === "dev",
+    isDefault: (branchId) => getType(branchId) === "default"
+  };
+};
+
+// src/domain/stack.ts
+var SERVICE_URL_OVERRIDES = {
+  // The service URL for the Kai Assistant is incomplete; we need to add the `/api` suffix to get the full URL for the API.
+  // I assume the service is versioned.
+  "kai-assistant": (url) => `${url}/api`
 };
 var createStack = ({ stackInfo, clientServiceUrls }) => {
   const { services, components, features, ...infoRest } = stackInfo;
@@ -447,194 +845,788 @@ var createVariablesSdk = ({ storageClient }) => {
       values: Array.isArray(rawValues) ? rawValues : []
     };
   };
-  const createVariables = async (definitions, values, branchId) => {
-    const config = await configs.createConfiguration({
-      branchId,
-      componentId: VARIABLES_COMPONENT_ID,
-      name: "Variables definition",
-      configuration: { variables: definitions }
-    });
-    try {
-      const row = await configs.createConfigurationRow({
-        branchId,
-        componentId: VARIABLES_COMPONENT_ID,
-        configId: config.id,
-        name: "Default values",
-        configuration: { values }
-      });
-      return { variablesId: config.id, variablesValuesId: row.id };
-    } catch (error) {
-      await configs.deleteConfiguration({
-        branchId,
-        componentId: VARIABLES_COMPONENT_ID,
-        configId: config.id
-      }).catch((cleanupError) => {
-        if (error instanceof Error && error.cause === void 0) {
-          error.cause = cleanupError;
-        }
-      });
-      throw error;
+  const createVariables = async (definitions, values, branchId) => {
+    const config = await configs.createConfiguration({
+      branchId,
+      componentId: VARIABLES_COMPONENT_ID,
+      name: "Variables definition",
+      configuration: { variables: definitions }
+    });
+    try {
+      const row = await configs.createConfigurationRow({
+        branchId,
+        componentId: VARIABLES_COMPONENT_ID,
+        configId: config.id,
+        name: "Default values",
+        configuration: { values }
+      });
+      return { variablesId: config.id, variablesValuesId: row.id };
+    } catch (error) {
+      await configs.deleteConfiguration({
+        branchId,
+        componentId: VARIABLES_COMPONENT_ID,
+        configId: config.id
+      }).catch((cleanupError) => {
+        if (error instanceof Error && error.cause === void 0) {
+          error.cause = cleanupError;
+        }
+      });
+      throw error;
+    }
+  };
+  return {
+    /** Copy a variables config into a fresh, independent config + values row. */
+    copy: async ({
+      variablesId,
+      variablesValuesId,
+      branchId = "default"
+    }) => {
+      const { definitions, values } = await readVariables(variablesId, variablesValuesId, branchId);
+      return createVariables(definitions, values, branchId);
+    },
+    /** Merge the source's variables into the target's and create a fresh merged config + values row. */
+    merge: async ({
+      targetVariablesId,
+      targetValuesId,
+      sourceVariablesId,
+      sourceValuesId,
+      branchId = "default"
+    }) => {
+      const [target, source] = await Promise.all([
+        readVariables(targetVariablesId, targetValuesId, branchId),
+        readVariables(sourceVariablesId, sourceValuesId, branchId)
+      ]);
+      return createVariables(
+        mergeVariableDefinitions(target.definitions, source.definitions),
+        mergeVariableValues(target.values, source.values),
+        branchId
+      );
+    }
+  };
+};
+var agentSettingsSchema = z2.z.object({
+  projectId: z2.z.string(),
+  customInstructions: z2.z.string().nullable(),
+  createdAt: z2.z.string(),
+  updatedAt: z2.z.string()
+});
+var toolPermissionValueSchema = z2.z.enum(["always_allow", "always_ask", "blocked"]);
+var userAgentSettingsSchema = z2.z.object({
+  projectId: z2.z.string(),
+  userId: z2.z.string(),
+  customInstructions: z2.z.string().nullable(),
+  toolPermissions: z2.z.record(z2.z.string(), toolPermissionValueSchema).nullable(),
+  createdAt: z2.z.string(),
+  updatedAt: z2.z.string()
+});
+var toolInfoSchema = z2.z.object({
+  name: z2.z.string(),
+  description: z2.z.string(),
+  readOnly: z2.z.boolean()
+});
+var toolsListResponseSchema = z2.z.object({
+  tools: z2.z.array(toolInfoSchema)
+});
+var skillInfoSchema = z2.z.object({
+  name: z2.z.string(),
+  description: z2.z.string().nullable(),
+  source: z2.z.enum(["first-party", "vendored", "project"])
+});
+var builtInCommandSchema = z2.z.object({
+  name: z2.z.string(),
+  description: z2.z.string()
+});
+var skillsListResponseSchema = z2.z.object({
+  skills: z2.z.array(skillInfoSchema),
+  commands: z2.z.array(builtInCommandSchema)
+});
+var sandboxFileEntrySchema = z2.z.object({
+  name: z2.z.string(),
+  path: z2.z.string(),
+  type: z2.z.enum(["file", "dir"]),
+  size: z2.z.number().int().nonnegative().optional()
+});
+var sandboxFileListingSchema = z2.z.object({
+  entries: z2.z.array(sandboxFileEntrySchema)
+});
+var sandboxFileContentSchema = z2.z.object({
+  content: z2.z.string(),
+  encoding: z2.z.enum(["utf-8", "binary"]),
+  truncated: z2.z.boolean(),
+  size: z2.z.number().int().nonnegative()
+});
+var sandboxGitBranchSchema = z2.z.object({
+  branch: z2.z.string().nullable()
+});
+var votesResponseSchema = z2.z.array(
+  z2.z.object({
+    chatId: z2.z.string(),
+    messageId: z2.z.string(),
+    isUpvoted: z2.z.boolean()
+  })
+);
+var createKaiAgentClient = ({ baseUrl, middlewares, auth }) => {
+  const clientOptions = {
+    baseUrl,
+    middlewares,
+    headers: chunk43CGBOVT_cjs.createAuthHeaders(auth)
+  };
+  const client = chunkDMNWPVVT_cjs.createOpenapiFetchClient(clientOptions);
+  const genericClient = chunkDMNWPVVT_cjs.createGenericFetchClient(clientOptions);
+  const getHistory = async (params) => {
+    const { data } = await client.get("/api/history", { query: params });
+    return data;
+  };
+  const getChat = async (chatId, signal) => {
+    const { data } = await client.get("/api/chat/{id}", { path: { id: chatId } }, { signal });
+    return data;
+  };
+  const deleteChat = async (chatId) => {
+    const { data } = await client.delete("/api/chat", { query: { id: chatId } });
+    return data;
+  };
+  const createChat = async (request) => {
+    const { response } = await client.post("/api/chat", { body: request });
+    return response;
+  };
+  const getVotes = async (chatId) => {
+    const { data } = await client.get("/api/vote", { query: { chatId } });
+    const result = votesResponseSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid votes response format");
+    }
+    return result.data;
+  };
+  const submitVote = async (params) => {
+    await client.patch("/api/vote", { body: params });
+  };
+  const getUsage = async (signal) => {
+    const { data } = await client.get("/api/usage", {}, { signal });
+    return data;
+  };
+  const approveToolCall = async (chatId, body) => {
+    await client.post("/api/chat/{id}/approval", { path: { id: chatId }, body });
+  };
+  const submitToolOutput = async (chatId, body) => {
+    await client.post("/api/chat/{id}/ui-tool-result", { path: { id: chatId }, body });
+  };
+  const stopChat = async (chatId) => {
+    const { data } = await client.post("/api/chat/{id}/stop", { path: { id: chatId } });
+    return data;
+  };
+  const getSuggestions = async (request, signal) => {
+    const { data } = await client.post("/api/suggestions", { body: request }, { signal });
+    return data;
+  };
+  const getAgentSettings = async (signal) => {
+    const { data } = await genericClient.get("/api/settings", {}, { signal });
+    const result = agentSettingsSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid agent settings response format");
+    }
+    return result.data;
+  };
+  const updateAgentSettings = async (request, signal) => {
+    const { data } = await genericClient.patch(
+      "/api/settings",
+      { body: request },
+      { signal }
+    );
+    const result = agentSettingsSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid agent settings response format");
+    }
+    return result.data;
+  };
+  const getUserAgentSettings = async (signal) => {
+    const { data } = await genericClient.get(
+      "/api/settings/user",
+      {},
+      { signal }
+    );
+    const result = userAgentSettingsSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid user agent settings response format");
+    }
+    return result.data;
+  };
+  const updateUserAgentSettings = async (request, signal) => {
+    const { data } = await genericClient.patch(
+      "/api/settings/user",
+      { body: request },
+      { signal }
+    );
+    const result = userAgentSettingsSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid user agent settings response format");
+    }
+    return result.data;
+  };
+  const getToolsList = async (signal) => {
+    const { data } = await genericClient.get(
+      "/api/settings/tools",
+      {},
+      { signal }
+    );
+    const result = toolsListResponseSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid tools list response format");
+    }
+    return result.data;
+  };
+  const getSkillsList = async (signal) => {
+    const { data } = await genericClient.get("/api/skills", {}, { signal });
+    const result = skillsListResponseSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid skills list response format");
+    }
+    return result.data;
+  };
+  const listSandboxFiles = async (chatId, path, signal) => {
+    const { data } = await genericClient.get(
+      `/api/chat/${encodeURIComponent(chatId)}/sandbox/files`,
+      { query: path ? { path } : void 0 },
+      { signal }
+    );
+    const result = sandboxFileListingSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid sandbox files response format");
+    }
+    return result.data;
+  };
+  const readSandboxFile = async (chatId, path, signal) => {
+    const { data } = await genericClient.get(
+      `/api/chat/${encodeURIComponent(chatId)}/sandbox/file`,
+      { query: { path } },
+      { signal }
+    );
+    const result = sandboxFileContentSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid sandbox file response format");
     }
+    return result.data;
   };
-  return {
-    /** Copy a variables config into a fresh, independent config + values row. */
-    copy: async ({
-      variablesId,
-      variablesValuesId,
-      branchId = "default"
-    }) => {
-      const { definitions, values } = await readVariables(variablesId, variablesValuesId, branchId);
-      return createVariables(definitions, values, branchId);
-    },
-    /** Merge the source's variables into the target's and create a fresh merged config + values row. */
-    merge: async ({
-      targetVariablesId,
-      targetValuesId,
-      sourceVariablesId,
-      sourceValuesId,
-      branchId = "default"
-    }) => {
-      const [target, source] = await Promise.all([
-        readVariables(targetVariablesId, targetValuesId, branchId),
-        readVariables(sourceVariablesId, sourceValuesId, branchId)
-      ]);
-      return createVariables(
-        mergeVariableDefinitions(target.definitions, source.definitions),
-        mergeVariableValues(target.values, source.values),
-        branchId
-      );
+  const getSandboxGitBranch = async (chatId, signal) => {
+    const { data } = await genericClient.get(
+      `/api/chat/${encodeURIComponent(chatId)}/sandbox/git-branch`,
+      {},
+      { signal }
+    );
+    const result = sandboxGitBranchSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid sandbox git-branch response format");
     }
+    return result.data;
   };
-};
-
-// src/createMiddlewareFor.ts
-var createMiddlewareFor = (middlewares) => {
-  return (target, baseline = []) => {
-    if (Array.isArray(middlewares)) return [...baseline, ...middlewares];
-    const all = middlewares?.all ?? [];
-    const targeted = middlewares?.[target] ?? [];
-    return [...baseline, ...all, ...targeted];
+  const chatStreamUrl = clientOptions.baseUrl + "/api/chat";
+  return {
+    getHistory,
+    getChat,
+    deleteChat,
+    createChat,
+    getVotes,
+    submitVote,
+    getUsage,
+    approveToolCall,
+    submitToolOutput,
+    stopChat,
+    getSuggestions,
+    getAgentSettings,
+    updateAgentSettings,
+    getUserAgentSettings,
+    updateUserAgentSettings,
+    getToolsList,
+    getSkillsList,
+    listSandboxFiles,
+    readSandboxFile,
+    getSandboxGitBranch,
+    chatStreamUrl
   };
 };
 
-// src/serviceClientRegistry/utils.ts
-var isBuiltInProperty = (property) => typeof property === "symbol" || property === "then" || property === "constructor" || property === "toString" || property === "valueOf";
-var createDummyClient = ({
-  onCall
+// src/keboola/createServiceClients.ts
+var createServiceClients = ({
+  baseUrl,
+  auth,
+  getServiceBaseUrl,
+  middlewareFor,
+  attachTokenMiddleware
+}) => createServiceClientRegistry()({
+  getServiceBaseUrl,
+  onUnavailable: ({ serviceId, path, clientName }) => {
+    throw new chunkHZSZQFEO_cjs.ServiceUnavailableError(serviceId, path, clientName);
+  }
+}).add({
+  serviceId: "vault",
+  clientName: "vault",
+  clientFn: (serviceBaseUrl) => chunkK6EZ3USU_cjs.createVaultClient({
+    baseUrl: serviceBaseUrl,
+    middlewares: middlewareFor("vault", [attachTokenMiddleware]),
+    auth
+  })
+}).add({
+  serviceId: "data-science",
+  clientName: "dataScience",
+  clientFn: (serviceBaseUrl) => chunkBWBTNAVL_cjs.createDataScienceClient({
+    baseUrl: serviceBaseUrl,
+    middlewares: middlewareFor("dataScience", [attachTokenMiddleware]),
+    auth
+  })
+}).add({
+  serviceId: "encryption",
+  clientName: "encryption",
+  clientFn: (serviceBaseUrl) => chunkCCC6I32C_cjs.createEncryptionClient({
+    baseUrl: serviceBaseUrl,
+    middlewares: middlewareFor("encryption")
+  })
+}).add({
+  serviceId: "editor",
+  clientName: "editor",
+  clientFn: (serviceBaseUrl) => chunkYQEBJG5H_cjs.createEditorClient({
+    baseUrl: serviceBaseUrl,
+    middlewares: middlewareFor("editor", [attachTokenMiddleware]),
+    auth
+  })
+}).add({
+  serviceId: "sync-actions",
+  clientName: "syncActions",
+  clientFn: (serviceBaseUrl) => chunkQ7C2IRF2_cjs.createSyncActionsClient({
+    baseUrl: serviceBaseUrl,
+    middlewares: middlewareFor("syncActions", [attachTokenMiddleware]),
+    auth
+  })
+}).add({
+  serviceId: "telemetry",
+  clientName: "telemetry",
+  clientFn: (serviceBaseUrl) => chunk5ZOWA7DA_cjs.createTelemetryClient({
+    baseUrl: serviceBaseUrl,
+    middlewares: middlewareFor("telemetry", [attachTokenMiddleware]),
+    auth
+  })
+}).add({
+  serviceId: "query",
+  clientName: "queryService",
+  clientFn: (serviceBaseUrl) => chunkWZGBE4XH_cjs.createQueryServiceClient({
+    baseUrl: serviceBaseUrl,
+    middlewares: middlewareFor("queryService", [attachTokenMiddleware]),
+    auth
+  })
+}).add({
+  serviceId: "queue",
+  clientName: "queue",
+  clientFn: (serviceBaseUrl) => chunkX4HEWMPU_cjs.createQueueClient({
+    baseUrl: serviceBaseUrl,
+    middlewares: middlewareFor("queue", [attachTokenMiddleware]),
+    auth
+  })
+}).add({
+  serviceId: "kai-assistant",
+  clientName: "chat",
+  clientFn: (serviceBaseUrl) => chunkFVJC2GJY_cjs.createChatClient({
+    storageApiUrl: baseUrl,
+    baseUrl: serviceBaseUrl,
+    middlewares: middlewareFor("chat", [attachTokenMiddleware]),
+    auth
+  })
+}).add({
+  serviceId: "ai",
+  clientName: "ai",
+  clientFn: (serviceBaseUrl) => chunk556U6PFA_cjs.createAiClient({
+    baseUrl: serviceBaseUrl,
+    middlewares: middlewareFor("ai", [attachTokenMiddleware]),
+    auth
+  })
+}).add({
+  serviceId: "import",
+  clientName: "import",
+  clientFn: (serviceBaseUrl) => chunkVPNWX7YM_cjs.createImportClient({
+    baseUrl: serviceBaseUrl,
+    middlewares: middlewareFor("import", [attachTokenMiddleware]),
+    auth
+  })
+}).add({
+  serviceId: "kai-agent",
+  clientName: "kaiAgent",
+  clientFn: (serviceBaseUrl) => createKaiAgentClient({
+    baseUrl: serviceBaseUrl,
+    middlewares: middlewareFor("kaiAgent", [attachTokenMiddleware]),
+    auth
+  })
+}).add({
+  serviceId: "oauth",
+  clientName: "oauth",
+  clientFn: (serviceBaseUrl) => chunkFDTWXXI4_cjs.createOauthClient({
+    baseUrl: serviceBaseUrl,
+    middlewares: middlewareFor("oauth", [attachTokenMiddleware]),
+    auth
+  })
+}).add({
+  serviceId: "scheduler",
+  clientName: "scheduler",
+  clientFn: (serviceBaseUrl) => chunkT7SEZMQ7_cjs.createSchedulerClient({
+    baseUrl: serviceBaseUrl,
+    middlewares: middlewareFor("scheduler", [attachTokenMiddleware]),
+    auth
+  })
+}).add({
+  serviceId: "stream",
+  clientName: "stream",
+  clientFn: (serviceBaseUrl) => chunkKY4EYQ6I_cjs.createStreamClient({
+    baseUrl: serviceBaseUrl,
+    middlewares: middlewareFor("stream", [attachTokenMiddleware]),
+    auth
+  })
+}).add({
+  serviceId: "notification",
+  clientName: "notifications",
+  clientFn: (serviceBaseUrl) => chunk4GUUSO5O_cjs.createNotificationsClient({
+    baseUrl: serviceBaseUrl,
+    middlewares: middlewareFor("notifications", [attachTokenMiddleware]),
+    auth
+  })
+}).add({
+  serviceId: "metastore",
+  clientName: "metastore",
+  clientFn: (serviceBaseUrl) => chunkCN5GAKRO_cjs.createMetastoreClient({
+    baseUrl: serviceBaseUrl,
+    middlewares: middlewareFor("metastore", [attachTokenMiddleware]),
+    auth
+  })
+}).build();
+
+// src/keboola/bearer/createProjectClients.ts
+var createProjectClients = async ({
+  baseUrl,
+  projectId,
+  authMiddleware,
+  middlewareFor,
+  clientServiceUrls
 }) => {
-  const createProxy = (path = []) => new Proxy(() => {
-  }, {
-    // Create a new proxy for nested property access
-    get: (_target, prop) => {
-      if (isBuiltInProperty(prop)) return void 0;
-      return createProxy([...path, prop]);
+  const auth = { type: "bearer", token: "", projectId };
+  const projectIdMiddleware = (next) => (request) => {
+    request.request.headers.set(chunkDMNWPVVT_cjs.KeboolaHttpHeader.PROJECT_ID, String(projectId));
+    return next(request);
+  };
+  const attach = (next) => projectIdMiddleware(authMiddleware(next));
+  const reader = chunkHZSZQFEO_cjs.createStorageClient({ baseUrl, auth, middlewares: [attach] });
+  const [stackInfo, sapiToken, devBranches] = await Promise.all([
+    reader.getStackInfo({ exclude: "componentDetails" }),
+    reader.tokens.verify(),
+    reader.branches.getDevBranches()
+  ]);
+  const stack = createStack({ stackInfo, clientServiceUrls });
+  const defaultBranch = createDefaultBranch({ devBranches });
+  const liveProject = createLiveProject({
+    initialToken: sapiToken,
+    verify: () => reader.tokens.verify()
+  });
+  const storageTableStore = createDerivedStore({
+    source: liveProject.store,
+    build: chunkUUY6LQT6_cjs.createStorageTable,
+    dependsOn: (project) => ({
+      useLegacyBucketPrefix: !project.hasFeature(chunk3FZHFTLG_cjs.ProjectFeature.DisableLegacyBucketPrefix),
+      hasProtectedDefaultBranch: project.hasFeature(chunk3FZHFTLG_cjs.ProjectFeature.SoxProtectedDefaultBranch),
+      hasStorageBranches: project.hasFeature(chunk3FZHFTLG_cjs.ProjectFeature.StorageBranches)
+    })
+  });
+  const context = {
+    baseUrl: chunkDMNWPVVT_cjs.normalizeBaseUrl(baseUrl),
+    stack,
+    defaultBranch,
+    get project() {
+      return liveProject.getProject();
     },
-    // When called as a function, invoke the interceptor
-    apply: (_target, _thisArgs, args) => onCall(path, args)
+    get st() {
+      return storageTableStore.get();
+    }
+  };
+  const storage = chunkHZSZQFEO_cjs.createStorageClient({
+    baseUrl,
+    auth,
+    middlewares: middlewareFor("storage", [attach, liveProject.middleware])
   });
-  return createProxy();
+  const { client: services, meta: serviceMeta } = createServiceClients({
+    baseUrl,
+    auth,
+    getServiceBaseUrl: context.stack.getServiceUrl,
+    middlewareFor,
+    attachTokenMiddleware: attach
+  });
+  const sdk = {
+    configuration: chunkZ76DIRLA_cjs.createConfigurationSdk({
+      storageClient: storage,
+      encryptionClient: services.encryption,
+      context
+    }),
+    tag: chunkFRLSKIUI_cjs.createTagSdk({ metastoreClient: services.metastore }),
+    semanticLayer: chunkKUYVBCUM_cjs.createSemanticLayerSdk({ metastoreClient: services.metastore }),
+    storage: chunk35MODDCL_cjs.createStorageSdk({ storageClient: storage }),
+    vault: chunkEYIPM2XB_cjs.createVaultSdk({ vaultClient: services.vault, encryptionClient: services.encryption }),
+    variables: createVariablesSdk({ storageClient: storage })
+  };
+  return { context, serviceMeta, storage, ...services, sdk };
 };
 
-// src/serviceClientRegistry/createServiceClientRegistry.ts
-var createServiceClientRegistry = () => ({
-  getServiceBaseUrl,
-  onUnavailable
+// src/keboola/bearer/credential.ts
+var DEFAULT_REFRESH_THRESHOLD = 0.9;
+var isUnauthorized = (error) => error instanceof chunkDMNWPVVT_cjs.ApiError && error.response.status === chunkDMNWPVVT_cjs.HttpStatus.UNAUTHORIZED;
+var createBearerCredential = ({
+  refresh,
+  getToken,
+  onSessionExpired,
+  refreshThreshold = DEFAULT_REFRESH_THRESHOLD
 }) => {
-  const dummy = (serviceId, clientName) => createDummyClient({
-    onCall: (path, args) => {
-      onUnavailable?.({
-        serviceId,
-        path,
-        args,
-        clientName
-      });
+  const doRefresh = async () => {
+    try {
+      return await refresh();
+    } catch (error) {
+      if (isUnauthorized(error)) onSessionExpired?.();
+      throw error;
     }
-  });
-  const configs = [];
-  const resolveClient = ({
-    serviceId,
-    clientFn,
-    clientName
-  }) => {
-    const serviceBaseUrl = getServiceBaseUrl(serviceId);
-    return serviceBaseUrl ? clientFn(serviceBaseUrl) : dummy(serviceId, clientName);
   };
-  const registry = {
-    add: (config) => {
-      configs.push(config);
-      return registry;
-    },
-    build: () => {
-      const clientMap = {};
-      const clientMeta = [];
-      configs.forEach((config) => {
-        clientMap[config.clientName] = resolveClient(config);
-        clientMeta.push({
-          clientName: config.clientName,
-          serviceId: config.serviceId,
-          isAvailable: !!getServiceBaseUrl(config.serviceId)
-        });
-      });
-      return {
-        client: clientMap,
-        meta: clientMeta
-      };
-    }
+  const refreshShared = chunk22D55AHX_cjs.dedupe(doRefresh);
+  const refreshAt = (timing) => timing.issuedAt + timing.expiresIn * 1e3 * refreshThreshold;
+  const getAccessToken = async ({ forceRefresh = false } = {}) => {
+    const snapshot = getToken();
+    if (snapshot === null) return null;
+    const { accessToken, timing } = snapshot;
+    if (forceRefresh) return refreshShared();
+    if (Date.now() < refreshAt(timing)) return accessToken;
+    return refreshShared().catch(() => accessToken);
   };
-  return registry;
+  return { getAccessToken, notifyExpired: () => onSessionExpired?.() };
 };
 
-// src/client.ts
-var createAttachTokenMiddleware = (getToken) => (next) => (request) => {
-  request.request.headers.set(chunkIUN2ZSU3_cjs.KeboolaHttpHeader.STORAGE_API_TOKEN, getToken());
-  return next(request);
+// src/keboola/bearer/middleware.ts
+var createBearerAuthMiddleware = (credential) => {
+  return (next) => async (request) => {
+    const token = await credential.getAccessToken({ forceRefresh: false });
+    if (token === null) return next(request);
+    const retryRequest = request.request.clone();
+    request.request.headers.set(chunkDMNWPVVT_cjs.HttpHeader.AUTHORIZATION, `Bearer ${token}`);
+    try {
+      return await next(request);
+    } catch (error) {
+      if (!isUnauthorized(error)) throw error;
+      const refreshed = await credential.getAccessToken({ forceRefresh: true });
+      if (refreshed === null) throw error;
+      retryRequest.headers.set(chunkDMNWPVVT_cjs.HttpHeader.AUTHORIZATION, `Bearer ${refreshed}`);
+      try {
+        return await next({ ...request, request: retryRequest });
+      } catch (retryError) {
+        if (isUnauthorized(retryError)) credential.notifyExpired();
+        throw retryError;
+      }
+    }
+  };
 };
-var STORAGE_TOKEN_MUTATING_PATTERNS = [
-  // Bucket lifecycle (create / delete / register) — changes token.bucketPermissions.
-  // At most one trailing segment, so sub-resources (tables, listing, metadata, refresh)
-  // under /buckets/{id}/... don't trigger a re-verify.
-  /\/buckets(\/[^/]+)?$/,
-  // Project feature toggles — changes token.owner.features. Anchored to
-  // /projects/{id}/features so /manage/features and /users/{id}/features don't match.
-  /\/projects\/[^/]+\/features(\/[^/]+)?$/
-];
-var isStorageTokenMutatingRequest = (request) => {
-  if (request.method === "GET") return false;
-  const { pathname } = new URL(request.url);
-  return STORAGE_TOKEN_MUTATING_PATTERNS.some((pattern) => pattern.test(pathname));
+var SESSION_KEY = "keboola:bearer-session";
+var persistedSessionSchema = z2__namespace.object({
+  baseUrl: z2__namespace.string().nullable(),
+  projectId: z2__namespace.number().nullable(),
+  refreshToken: z2__namespace.string().nullable()
+});
+var EMPTY_PERSISTED_SESSION = {
+  baseUrl: null,
+  projectId: null,
+  refreshToken: null
 };
-var createProjectRefreshMiddleware = (shouldRefresh, requestRefresh) => (next) => async (request) => {
-  const response = await next(request);
-  if (shouldRefresh(request.request)) await requestRefresh();
-  return response;
+var createSessionPersistor = (storage) => createPersistor({
+  storage,
+  key: SESSION_KEY,
+  schema: persistedSessionSchema,
+  defaultValue: EMPTY_PERSISTED_SESSION
+});
+
+// src/keboola/bearer/keboola.ts
+var createKeboola = (options = {}) => {
+  const persistor = createSessionPersistor(options.storage);
+  const config = createConfig();
+  const middlewareFor = createMiddlewareFor(options.middlewares);
+  const retryContention = createRetryMiddleware({
+    shouldRetry: (error) => error instanceof chunkDMNWPVVT_cjs.ApiError && error.response.status === chunkDMNWPVVT_cjs.HttpStatus.SERVICE_UNAVAILABLE
+  });
+  const authClientBare = createDerivedStore({
+    source: config.store,
+    dependsOn: (state) => state.baseUrl,
+    build: (baseUrl) => baseUrl ? chunkYEF46DYF_cjs.createAuthClient({ baseUrl, middlewares: middlewareFor("auth", [retryContention]) }) : null
+  });
+  const refresh = async () => {
+    const client = authClientBare.get();
+    assert2(client, KeboolaErrorType.NotReady);
+    const refreshed = await client.token.refresh(config.requireCredential().refreshToken);
+    config.applyRefresh(refreshed);
+    return refreshed.accessToken;
+  };
+  const getToken = () => {
+    const state = config.store.get();
+    if (state.status === "anonymous") return null;
+    const { accessToken, issuedAt, expiresIn } = state.credential;
+    return { accessToken, timing: { issuedAt, expiresIn } };
+  };
+  const signOut = () => {
+    config.reset();
+    persistor.clear();
+  };
+  const onSessionExpired = () => {
+    if (config.notifyExpired()) signOut();
+  };
+  const credential = createBearerCredential({ refresh, getToken, onSessionExpired });
+  const authMiddleware = createBearerAuthMiddleware(credential);
+  const authClient = createDerivedStore({
+    source: config.store,
+    dependsOn: (state) => state.baseUrl,
+    build: (baseUrl) => baseUrl ? chunkYEF46DYF_cjs.createAuthClient({
+      baseUrl,
+      middlewares: middlewareFor("auth", [retryContention, authMiddleware])
+    }) : null
+  });
+  const management = createDerivedStore({
+    source: config.store,
+    dependsOn: (state) => state.status === "anonymous" ? null : state.baseUrl,
+    build: (baseUrl) => baseUrl ? chunk22D55AHX_cjs.createManagementClient({
+      baseUrl,
+      auth: { type: "bearer", token: "" },
+      middlewares: middlewareFor("management", [authMiddleware])
+    }) : null
+  });
+  const projectClientsAsync = createDerivedAsyncStore({
+    source: config.store,
+    // Keyed on baseUrl + projectId only — a rotation (new credential, same project) must not rebuild.
+    dependsOn: (state) => state.status === "scoped" ? { baseUrl: state.baseUrl, projectId: state.projectId } : null,
+    build: ({ baseUrl, projectId }) => {
+      return createProjectClients({
+        baseUrl,
+        authMiddleware,
+        projectId,
+        middlewareFor,
+        clientServiceUrls: options.clientServiceUrls
+      });
+    }
+  });
+  if (options.baseUrl) config.setBaseUrl(options.baseUrl);
+  config.store.subscribe((state) => {
+    if (state.status === "anonymous") return;
+    persistor.persist({
+      baseUrl: state.baseUrl,
+      projectId: state.status === "scoped" ? state.projectId : null,
+      refreshToken: state.credential.refreshToken
+    });
+  });
+  const debug = () => ({
+    type: "Bearer",
+    config: config.debug(),
+    authReady: authClient.get() !== null,
+    managementReady: management.get() !== null,
+    storage: projectClientsAsync.store.get().state
+  });
+  const session = {
+    hasPersistedValue: persistor.hasPersistedValue,
+    setBaseUrl: config.setBaseUrl,
+    isStorageReady: () => projectClientsAsync.store.get().state === "ready",
+    authenticate: (tokens) => config.authenticate(tokens),
+    setProject: config.setProjectId,
+    setProjectAsync: async (projectId) => {
+      config.setProjectId(projectId);
+      await projectClientsAsync.settled();
+    },
+    /**
+     * Leave the current project but stay signed in — the storage build returns to `idle`, so a
+     * consumer gating on it falls back to its project picker. The persisted session is rewritten with
+     * `projectId: null` by the subscription above, so a reload lands on the picker rather than
+     * re-entering the project. Use `reset` to sign out instead.
+     */
+    clearProject: config.clearProjectId,
+    reset: signOut,
+    /**
+     * Dev/test only: mark the current access token as expired so the bearer credential rotates it on
+     * the next request. Pair with any authenticated call (e.g. `api.storage.tokens.verify()`) to force
+     * the rotation immediately and observe the new credential.
+     */
+    debugForceRefresh: config.forceExpire,
+    restore: async () => {
+      const persisted = persistor.hydrate();
+      if (!persisted.refreshToken || !persisted.baseUrl) return { status: "empty" };
+      const configured = config.getBaseUrl();
+      if (configured && configured !== persisted.baseUrl) {
+        persistor.clear();
+        return { status: "empty" };
+      }
+      if (!configured) config.setBaseUrl(persisted.baseUrl);
+      const client = authClientBare.get();
+      assert2(client, KeboolaErrorType.NotReady);
+      try {
+        const refreshed = await client.token.refresh(persisted.refreshToken);
+        config.authenticate(refreshed);
+        if (persisted.projectId !== null) {
+          config.setProjectId(persisted.projectId);
+          await projectClientsAsync.settled();
+        }
+        return { status: "restored" };
+      } catch (err) {
+        if (isUnauthorized(err)) {
+          persistor.clear();
+          return { status: "expired" };
+        }
+        throw err;
+      }
+    },
+    subscribe: (listener) => {
+      const unsubscribeConfig = config.store.subscribe(() => listener(debug()));
+      const unsubscribeBuild = projectClientsAsync.store.subscribe(() => listener(debug()));
+      return () => {
+        unsubscribeConfig();
+        unsubscribeBuild();
+      };
+    },
+    debug
+  };
+  const api = createApi({
+    getAuthClient: () => authClient.get(),
+    getManagementClient: () => management.get(),
+    getProjectClients: () => {
+      const state = projectClientsAsync.store.get();
+      return state.state === "ready" ? state.value : null;
+    }
+  });
+  return { api, session };
 };
-var createLiveProject = ({
-  initialToken,
-  verify
-}) => {
-  const store = createStore(chunkGF4XZK5N_cjs.createProject({ sapiToken: initialToken }));
-  const refresh = coalesce(async () => store.set(chunkGF4XZK5N_cjs.createProject({ sapiToken: await verify() })));
-  const middleware = createProjectRefreshMiddleware(isStorageTokenMutatingRequest, refresh);
-  return { store, getProject: () => store.get(), subscribe: store.subscribe, middleware };
+
+// src/keboola/legacy/createConfig.ts
+var createConfig2 = () => {
+  const store = createStore({ baseUrl: null, sapiToken: null, managementToken: null });
+  const setBaseUrl = (baseUrl) => {
+    store.set({ ...store.get(), baseUrl });
+  };
+  const authenticate = (tokens) => {
+    const current = store.get();
+    store.set({
+      ...current,
+      sapiToken: tokens.sapiToken ?? current.sapiToken,
+      managementToken: tokens.managementToken ?? current.managementToken
+    });
+  };
+  const getStorageToken = () => store.get().sapiToken ?? "";
+  const setStorageToken = (sapiToken) => store.set({ ...store.get(), sapiToken });
+  const debug = () => store.get();
+  return { store, setBaseUrl, authenticate, getStorageToken, setStorageToken, debug };
 };
-var createLiveToken = ({ initialToken }) => {
-  const store = createStore(initialToken);
-  const attachTokenMiddleware = createAttachTokenMiddleware(() => store.get());
-  return { attachTokenMiddleware, set: store.set };
+
+// src/keboola/legacy/createProjectClients.ts
+var createAttachStorageToken = (getToken) => (next) => (request) => {
+  request.request.headers.set(chunkDMNWPVVT_cjs.KeboolaHttpHeader.STORAGE_API_TOKEN, getToken());
+  return next(request);
 };
-var createClients = async ({
+var createProjectClients2 = async ({
   baseUrl,
-  token,
-  clientServiceUrls,
-  middlewares
+  getStorageToken,
+  onStorageTokenRefreshed,
+  middlewareFor,
+  clientServiceUrls
 }) => {
-  const middlewareFor = createMiddlewareFor(middlewares);
-  const liveToken = createLiveToken({ initialToken: token.storageApi });
-  const _storage = chunk4JCVPUXF_cjs.createStorageClient({
-    baseUrl,
-    auth: { type: "sapi-token", token: token.storageApi },
-    middlewares: [liveToken.attachTokenMiddleware]
-  });
+  const auth = { type: "sapi-token", token: getStorageToken() };
+  const attach = createAttachStorageToken(getStorageToken);
+  const _storage = chunkHZSZQFEO_cjs.createStorageClient({ baseUrl, auth, middlewares: [attach] });
   const [stackInfo, sapiToken, devBranches] = await Promise.all([
     _storage.getStackInfo({ exclude: "componentDetails" }),
     _storage.tokens.verify(),
@@ -655,177 +1647,8 @@ var createClients = async ({
       hasStorageBranches: project.hasFeature(chunk3FZHFTLG_cjs.ProjectFeature.StorageBranches)
     })
   });
-  const storage = chunk4JCVPUXF_cjs.createStorageClient({
-    baseUrl,
-    auth: { type: "sapi-token", token: token.storageApi },
-    middlewares: middlewareFor("storage", [liveProject.middleware]),
-    onRefreshToken: liveToken.set
-  });
-  const management = chunkSWJHENEP_cjs.createManagementClient({
-    baseUrl,
-    auth: { type: "management-token", token: token.managementApi },
-    middlewares: middlewareFor("management", [liveProject.middleware])
-  });
-  const auth = chunkN3GNUFMA_cjs.createAuthClient({
-    baseUrl,
-    middlewares: middlewareFor("auth")
-  });
-  const { client, meta } = createServiceClientRegistry()({
-    getServiceBaseUrl: (serviceId) => stack.getServiceUrl(serviceId),
-    onUnavailable: ({ serviceId, path, clientName }) => {
-      throw new chunk4JCVPUXF_cjs.ServiceUnavailableError(serviceId, path, clientName);
-    }
-  }).add({
-    serviceId: "vault",
-    clientName: "vault",
-    clientFn: (serviceBaseUrl) => chunkANRUSNYD_cjs.createVaultClient({
-      baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("vault", [liveToken.attachTokenMiddleware]),
-      auth: { type: "sapi-token", token: token.storageApi }
-    })
-  }).add({
-    serviceId: "data-science",
-    clientName: "dataScience",
-    clientFn: (serviceBaseUrl) => chunk4H2DDEUI_cjs.createDataScienceClient({
-      baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("dataScience", [liveToken.attachTokenMiddleware]),
-      auth: { type: "sapi-token", token: token.storageApi }
-    })
-  }).add({
-    serviceId: "encryption",
-    clientName: "encryption",
-    clientFn: (serviceBaseUrl) => chunkNRJTA5P3_cjs.createEncryptionClient({
-      baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("encryption")
-    })
-  }).add({
-    serviceId: "editor",
-    clientName: "editor",
-    clientFn: (serviceBaseUrl) => chunkAKDJSXVJ_cjs.createEditorClient({
-      baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("editor", [liveToken.attachTokenMiddleware]),
-      auth: { type: "sapi-token", token: token.storageApi }
-    })
-  }).add({
-    serviceId: "sync-actions",
-    clientName: "syncActions",
-    clientFn: (serviceBaseUrl) => chunkSTAQJVW4_cjs.createSyncActionsClient({
-      baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("syncActions", [liveToken.attachTokenMiddleware]),
-      auth: { type: "sapi-token", token: token.storageApi }
-    })
-  }).add({
-    serviceId: "telemetry",
-    clientName: "telemetry",
-    clientFn: (serviceBaseUrl) => chunkXISA4SYM_cjs.createTelemetryClient({
-      baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("telemetry", [liveToken.attachTokenMiddleware]),
-      auth: { type: "sapi-token", token: token.storageApi }
-    })
-  }).add({
-    serviceId: "query",
-    clientName: "queryService",
-    clientFn: (serviceBaseUrl) => chunkYLHZ2H7O_cjs.createQueryServiceClient({
-      baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("queryService", [liveToken.attachTokenMiddleware]),
-      auth: { type: "sapi-token", token: token.storageApi }
-    })
-  }).add({
-    serviceId: "queue",
-    clientName: "queue",
-    clientFn: (serviceBaseUrl) => chunkYOPRPXER_cjs.createQueueClient({
-      baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("queue", [liveToken.attachTokenMiddleware]),
-      auth: { type: "sapi-token", token: token.storageApi }
-    })
-  }).add({
-    serviceId: "kai-assistant",
-    clientName: "chat",
-    clientFn: (serviceBaseUrl) => chunkJIAMBOU7_cjs.createChatClient({
-      storageApiUrl: baseUrl,
-      baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("chat", [liveToken.attachTokenMiddleware]),
-      auth: { type: "sapi-token", token: token.storageApi }
-    })
-  }).add({
-    serviceId: "ai",
-    clientName: "ai",
-    clientFn: (serviceBaseUrl) => chunkJJXTE2SL_cjs.createAiClient({
-      baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("ai", [liveToken.attachTokenMiddleware]),
-      auth: { type: "sapi-token", token: token.storageApi }
-    })
-  }).add({
-    serviceId: "import",
-    clientName: "import",
-    clientFn: (serviceBaseUrl) => chunkMLCMKHMK_cjs.createImportClient({
-      baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("import", [liveToken.attachTokenMiddleware]),
-      auth: { type: "sapi-token", token: token.storageApi }
-    })
-  }).add({
-    serviceId: "kai-agent",
-    clientName: "kaiAgent",
-    clientFn: (serviceBaseUrl) => createKaiAgentClient({
-      baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("kaiAgent", [liveToken.attachTokenMiddleware]),
-      auth: { type: "sapi-token", token: token.storageApi }
-    })
-  }).add({
-    serviceId: "oauth",
-    clientName: "oauth",
-    clientFn: (serviceBaseUrl) => chunkQQJXXNUE_cjs.createOauthClient({
-      baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("oauth", [liveToken.attachTokenMiddleware]),
-      auth: { type: "sapi-token", token: token.storageApi }
-    })
-  }).add({
-    serviceId: "scheduler",
-    clientName: "scheduler",
-    clientFn: (serviceBaseUrl) => chunkG7VCXMQB_cjs.createSchedulerClient({
-      baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("scheduler", [liveToken.attachTokenMiddleware]),
-      auth: { type: "sapi-token", token: token.storageApi }
-    })
-  }).add({
-    serviceId: "stream",
-    clientName: "stream",
-    clientFn: (serviceBaseUrl) => chunkEKWD4ODT_cjs.createStreamClient({
-      baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("stream", [liveToken.attachTokenMiddleware]),
-      auth: { type: "sapi-token", token: token.storageApi }
-    })
-  }).add({
-    serviceId: "notification",
-    clientName: "notifications",
-    clientFn: (serviceBaseUrl) => chunkIZWNTRMT_cjs.createNotificationsClient({
-      baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("notifications", [liveToken.attachTokenMiddleware]),
-      auth: { type: "sapi-token", token: token.storageApi }
-    })
-  }).add({
-    serviceId: "metastore",
-    clientName: "metastore",
-    clientFn: (serviceBaseUrl) => chunkZLW3243Q_cjs.createMetastoreClient({
-      baseUrl: serviceBaseUrl,
-      middlewares: middlewareFor("metastore", [liveToken.attachTokenMiddleware]),
-      auth: { type: "sapi-token", token: token.storageApi }
-    })
-  }).build();
-  const tag = chunkBR3SBEFE_cjs.createTagSdk({
-    metastoreClient: client.metastore
-  });
-  const storageSdk = chunkAWRMGLMT_cjs.createStorageSdk({
-    storageClient: storage
-  });
-  const vault = chunkIWIN6HKU_cjs.createVaultSdk({
-    vaultClient: client.vault,
-    encryptionClient: client.encryption
-  });
-  const variables = createVariablesSdk({
-    storageClient: storage
-  });
   const context = {
+    baseUrl: chunkDMNWPVVT_cjs.normalizeBaseUrl(baseUrl),
     stack,
     defaultBranch,
     get project() {
@@ -833,281 +1656,173 @@ var createClients = async ({
     },
     get st() {
       return storageTableStore.get();
-    },
-    serviceMeta: meta
+    }
   };
-  const configuration = chunkUFQVOZZ6_cjs.createConfigurationSdk({
-    storageClient: storage,
-    encryptionClient: client.encryption,
-    context
+  const storage = chunkHZSZQFEO_cjs.createStorageClient({
+    baseUrl,
+    auth,
+    middlewares: middlewareFor("storage", [liveProject.middleware]),
+    onRefreshToken: onStorageTokenRefreshed
   });
-  return {
-    context,
-    // clients
-    storage,
-    management,
+  const { client: services, meta: serviceMeta } = createServiceClients({
+    baseUrl,
     auth,
-    ...client,
-    sdk: {
-      configuration,
-      tag,
-      storage: storageSdk,
-      vault,
-      variables
-    }
-  };
-};
-var createApiClient = () => {
-  let clients = null;
-  const init = async (options) => {
-    if (clients) throw new Error("API is already initialized.");
-    clients = await createClients(options);
-  };
-  const result = { init };
-  const handler = {
-    get(_, property) {
-      if (isBuiltInProperty(property)) return void 0;
-      if (property === "init") return init;
-      assert(clients, `API is not initialized. Call init() before accessing ${String(property)}`);
-      return clients[property];
-    }
+    getServiceBaseUrl: context.stack.getServiceUrl,
+    middlewareFor,
+    attachTokenMiddleware: attach
+  });
+  const sdk = {
+    configuration: chunkZ76DIRLA_cjs.createConfigurationSdk({
+      storageClient: storage,
+      encryptionClient: services.encryption,
+      context
+    }),
+    tag: chunkFRLSKIUI_cjs.createTagSdk({ metastoreClient: services.metastore }),
+    semanticLayer: chunkKUYVBCUM_cjs.createSemanticLayerSdk({ metastoreClient: services.metastore }),
+    storage: chunk35MODDCL_cjs.createStorageSdk({ storageClient: storage }),
+    vault: chunkEYIPM2XB_cjs.createVaultSdk({ vaultClient: services.vault, encryptionClient: services.encryption }),
+    variables: createVariablesSdk({ storageClient: storage })
   };
-  return new Proxy(result, handler);
+  return { context, serviceMeta, storage, ...services, sdk };
 };
 
-// src/middlewares/loggingMiddleware.ts
-var CORRELATION_ID_HEADER = "X-Correlation-ID";
-var ALWAYS_REDACTED_HEADERS = [
-  chunkIUN2ZSU3_cjs.KeboolaHttpHeader.MANAGEMENT_API_TOKEN,
-  chunkIUN2ZSU3_cjs.KeboolaHttpHeader.STORAGE_API_TOKEN,
-  "authorization",
-  "cookie",
-  "set-cookie"
-];
-var ALWAYS_REDACTED_QUERY_PARAMS = /* @__PURE__ */ new Set([
-  "token",
-  "apikey",
-  "api_key",
-  "access_token",
-  "refresh_token",
-  "code",
-  "state",
-  "signature",
-  "sig",
-  "x-amz-signature",
-  "x-amz-credential",
-  "x-amz-security-token",
-  "password",
-  "secret"
-]);
-var REDACTED = "[REDACTED]";
-var getRedactedUrl = (rawUrl) => {
-  const url = new URL(rawUrl);
-  if (url.username) url.username = REDACTED;
-  if (url.password) url.password = REDACTED;
-  url.searchParams.forEach((_value, key) => {
-    if (ALWAYS_REDACTED_QUERY_PARAMS.has(key.toLowerCase())) {
-      url.searchParams.set(key, REDACTED);
-    }
+// src/keboola/legacy/keboola.ts
+var createLegacyKeboola = (options = {}) => {
+  const config = createConfig2();
+  const middlewareFor = createMiddlewareFor(options.middlewares);
+  const authClient = createDerivedStore({
+    source: config.store,
+    dependsOn: (state) => state.baseUrl,
+    build: (baseUrl) => baseUrl ? chunkYEF46DYF_cjs.createAuthClient({ baseUrl, middlewares: middlewareFor("auth", []) }) : null
   });
-  return url.toString();
-};
-var ensureCorrelationId = (request) => {
-  const correlationId = request.headers.get(CORRELATION_ID_HEADER) ?? chunkBR3SBEFE_cjs.generateUUID();
-  request.headers.set(CORRELATION_ID_HEADER, correlationId);
-  return correlationId;
-};
-var getRedactedHeaders = (headers, redacted) => {
-  const redactedSet = new Set(
-    [...ALWAYS_REDACTED_HEADERS, ...redacted].map((h) => h.toLowerCase())
-  );
-  const result = {};
-  headers.forEach((value, name) => {
-    result[name] = redactedSet.has(name.toLowerCase()) ? REDACTED : value;
+  const management = createDerivedStore({
+    source: config.store,
+    dependsOn: (state) => ({ baseUrl: state.baseUrl, token: state.managementToken }),
+    build: ({ baseUrl, token }) => baseUrl ? chunk22D55AHX_cjs.createManagementClient({
+      baseUrl,
+      auth: token ? { type: "management-token", token } : { type: "management-token" },
+      middlewares: middlewareFor("management", [])
+    }) : null
   });
-  return result;
-};
-var getRequestLog = (request, redactedHeaders) => ({
-  url: getRedactedUrl(request.url),
-  headers: getRedactedHeaders(request.headers, redactedHeaders)
-});
-var getResponseLog = (response, redactedHeaders) => ({
-  status: response.status,
-  statusText: response.statusText,
-  headers: getRedactedHeaders(response.headers, redactedHeaders)
-});
-var redactApiError = (error, redactedHeaders) => new chunkIUN2ZSU3_cjs.ApiError({
-  request: new Request(getRedactedUrl(error.request.url), {
-    method: error.request.method,
-    headers: getRedactedHeaders(error.request.headers, redactedHeaders)
-  }),
-  response: new Response(null, {
-    status: error.response.status,
-    statusText: error.response.statusText,
-    headers: getRedactedHeaders(error.response.headers, redactedHeaders)
-  }),
-  data: error.data
-});
-var formatLog = (level, log) => {
-  const parts = [`[${level.toUpperCase()}]`, `${Math.round(log.durationMs)}ms`, log.method];
-  parts.push(log.request.url);
-  if ("response" in log) parts.push(String(log.response.status));
-  return parts.join(" ");
-};
-var createSafeLogger = (logger, level = "error-only") => {
-  return {
-    info: (log) => {
-      if (level !== "all") return;
-      try {
-        if (logger?.info) {
-          logger.info(log);
-          return;
-        }
-        console.info(formatLog("info", log));
-      } catch {
-      }
-    },
-    error: (log) => {
-      try {
-        if (logger?.error) {
-          logger.error(log);
-          return;
-        }
-        console.error(formatLog("error", log));
-      } catch {
-      }
-    }
+  const build = createDerivedAsyncStore({
+    source: config.store,
+    dependsOn: (state) => state.sapiToken && state.baseUrl ? state.baseUrl : null,
+    build: (baseUrl) => createProjectClients2({
+      baseUrl,
+      getStorageToken: config.getStorageToken,
+      onStorageTokenRefreshed: config.setStorageToken,
+      middlewareFor,
+      clientServiceUrls: options.clientServiceUrls
+    })
+  });
+  if (options.baseUrl) config.setBaseUrl(options.baseUrl);
+  const debug = () => {
+    const info = config.debug();
+    return {
+      type: "Sapi",
+      config: info,
+      authReady: authClient.get() !== null,
+      managementReady: !!info.managementToken,
+      storage: build.store.get().state
+    };
   };
-};
-var createLoggingMiddleware = (options = {}) => {
-  const safeLogger = createSafeLogger(options.logger, options.level);
-  const redactHeaders = options.redactHeaders ?? [];
-  return (next) => async (fetchRequest) => {
-    const correlationId = ensureCorrelationId(fetchRequest.request);
-    const start = performance.now();
-    const method = fetchRequest.request.method.toLowerCase();
-    const requestLog = getRequestLog(fetchRequest.request, redactHeaders);
-    try {
-      const result = await next(fetchRequest);
-      safeLogger.info({
-        correlationId,
-        method,
-        durationMs: performance.now() - start,
-        request: requestLog,
-        response: getResponseLog(result.response, redactHeaders)
-      });
-      return result;
-    } catch (error) {
-      if (error instanceof Error)
-        safeLogger.error({
-          correlationId,
-          method,
-          durationMs: performance.now() - start,
-          request: requestLog,
-          error: chunkIUN2ZSU3_cjs.isApiError(error) ? redactApiError(error, redactHeaders) : error
-        });
-      throw error;
-    }
+  const session = {
+    setBaseUrl: config.setBaseUrl,
+    isStorageReady: () => build.store.get().state === "ready",
+    authenticateStorage: (sapiToken) => config.authenticate({ sapiToken }),
+    authenticateStorageAsync: async (sapiToken) => {
+      config.authenticate({ sapiToken });
+      await build.settled();
+    },
+    authenticateManagement: (managementToken) => config.authenticate({ managementToken }),
+    subscribe: (listener) => {
+      const unsubscribeConfig = config.store.subscribe(() => listener(debug()));
+      const unsubscribeBuild = build.store.subscribe(() => listener(debug()));
+      return () => {
+        unsubscribeConfig();
+        unsubscribeBuild();
+      };
+    },
+    debug
   };
-};
-
-// src/middlewares/retryMiddleware.ts
-var DEFAULT_MAX_RETRIES = 5;
-var DEFAULT_RETRYABLE_STATUSES = [
-  chunkIUN2ZSU3_cjs.HttpStatus.INTERNAL_SERVER_ERROR,
-  chunkIUN2ZSU3_cjs.HttpStatus.BAD_GATEWAY,
-  chunkIUN2ZSU3_cjs.HttpStatus.SERVICE_UNAVAILABLE,
-  chunkIUN2ZSU3_cjs.HttpStatus.GATEWAY_TIMEOUT
-];
-var DEFAULT_BACKOFF_FACTOR = 0.3;
-var defaultShouldRetry = (error) => error instanceof chunkIUN2ZSU3_cjs.ApiError && DEFAULT_RETRYABLE_STATUSES.includes(error.response.status);
-var createRetryMiddleware = (options) => {
-  const {
-    maxRetries = DEFAULT_MAX_RETRIES,
-    backoffFactor = DEFAULT_BACKOFF_FACTOR,
-    shouldRetry = defaultShouldRetry
-  } = options ?? {};
-  if (!Number.isInteger(maxRetries) || maxRetries < 0) {
-    throw new RangeError("maxRetries must be a non-negative integer");
-  }
-  if (!Number.isFinite(backoffFactor) || backoffFactor < 0) {
-    throw new RangeError("backoffFactor must be a finite non-negative number");
-  }
-  return (next) => async (request) => {
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      try {
-        return await next({ ...request, request: request.request.clone() });
-      } catch (error) {
-        if (attempt === maxRetries || !shouldRetry(error, attempt)) {
-          throw error;
-        }
-        const delayMs = backoffFactor * 1e3 * Math.pow(2, attempt);
-        await chunkAWRMGLMT_cjs.delay(delayMs, request.request.signal ?? void 0);
-      }
+  const api = createApi({
+    getAuthClient: () => authClient.get(),
+    getManagementClient: () => management.get(),
+    getProjectClients: () => {
+      const state = build.store.get();
+      return state.state === "ready" ? state.value : null;
     }
-    throw new Error("unreachable");
-  };
+  });
+  return { api, session };
 };
 
-Object.defineProperty(exports, "generateUUID", {
+Object.defineProperty(exports, "isEmptyDeep", {
+  enumerable: true,
+  get: function () { return chunkZ76DIRLA_cjs.isEmptyDeep; }
+});
+Object.defineProperty(exports, "schemaGuidedMerge", {
   enumerable: true,
-  get: function () { return chunkBR3SBEFE_cjs.generateUUID; }
+  get: function () { return chunkZ76DIRLA_cjs.schemaGuidedMerge; }
 });
 Object.defineProperty(exports, "keboolaUID", {
   enumerable: true,
-  get: function () { return chunkBR3SBEFE_cjs.keboolaUID; }
+  get: function () { return chunkFRLSKIUI_cjs.keboolaUID; }
+});
+Object.defineProperty(exports, "generateUUID", {
+  enumerable: true,
+  get: function () { return chunkEWMXK3EI_cjs.generateUUID; }
 });
 Object.defineProperty(exports, "PollException", {
   enumerable: true,
-  get: function () { return chunkAWRMGLMT_cjs.PollException; }
+  get: function () { return chunk35MODDCL_cjs.PollException; }
 });
 Object.defineProperty(exports, "createStorageSdk", {
   enumerable: true,
-  get: function () { return chunkAWRMGLMT_cjs.createStorageSdk; }
+  get: function () { return chunk35MODDCL_cjs.createStorageSdk; }
 });
 Object.defineProperty(exports, "delay", {
   enumerable: true,
-  get: function () { return chunkAWRMGLMT_cjs.delay; }
+  get: function () { return chunk35MODDCL_cjs.delay; }
 });
 Object.defineProperty(exports, "poll", {
   enumerable: true,
-  get: function () { return chunkAWRMGLMT_cjs.poll; }
-});
-Object.defineProperty(exports, "isEmptyDeep", {
-  enumerable: true,
-  get: function () { return chunkUFQVOZZ6_cjs.isEmptyDeep; }
-});
-Object.defineProperty(exports, "schemaGuidedMerge", {
-  enumerable: true,
-  get: function () { return chunkUFQVOZZ6_cjs.schemaGuidedMerge; }
+  get: function () { return chunk35MODDCL_cjs.poll; }
 });
 Object.defineProperty(exports, "ServiceUnavailableError", {
   enumerable: true,
-  get: function () { return chunk4JCVPUXF_cjs.ServiceUnavailableError; }
+  get: function () { return chunkHZSZQFEO_cjs.ServiceUnavailableError; }
 });
 Object.defineProperty(exports, "series", {
   enumerable: true,
-  get: function () { return chunk4JCVPUXF_cjs.series; }
-});
-Object.defineProperty(exports, "concurrent", {
-  enumerable: true,
-  get: function () { return chunkCVV4HROS_cjs.concurrent; }
+  get: function () { return chunkHZSZQFEO_cjs.series; }
 });
 Object.defineProperty(exports, "UserError", {
   enumerable: true,
   get: function () { return chunkRRC5RKF7_cjs.UserError; }
 });
+Object.defineProperty(exports, "dedupe", {
+  enumerable: true,
+  get: function () { return chunk22D55AHX_cjs.dedupe; }
+});
 Object.defineProperty(exports, "isManagementClientAuthError", {
   enumerable: true,
-  get: function () { return chunkSWJHENEP_cjs.isManagementClientAuthError; }
+  get: function () { return chunk22D55AHX_cjs.isManagementClientAuthError; }
 });
 Object.defineProperty(exports, "ManagementClientAuthError", {
   enumerable: true,
-  get: function () { return chunkWWICQYOY_cjs.ManagementClientAuthError; }
+  get: function () { return chunkIYGHWPCR_cjs.ManagementClientAuthError; }
+});
+Object.defineProperty(exports, "concurrent", {
+  enumerable: true,
+  get: function () { return chunkFMS5PNM2_cjs.concurrent; }
+});
+Object.defineProperty(exports, "collect", {
+  enumerable: true,
+  get: function () { return chunkX4HEWMPU_cjs.collect; }
 });
 Object.defineProperty(exports, "parseLogLines", {
   enumerable: true,
-  get: function () { return chunk4H2DDEUI_cjs.parseLogLines; }
+  get: function () { return chunkBWBTNAVL_cjs.parseLogLines; }
 });
 Object.defineProperty(exports, "isPlainObject", {
   enumerable: true,
@@ -1115,45 +1830,54 @@ Object.defineProperty(exports, "isPlainObject", {
 });
 Object.defineProperty(exports, "ApiError", {
   enumerable: true,
-  get: function () { return chunkIUN2ZSU3_cjs.ApiError; }
+  get: function () { return chunkDMNWPVVT_cjs.ApiError; }
 });
 Object.defineProperty(exports, "HttpContentType", {
   enumerable: true,
-  get: function () { return chunkIUN2ZSU3_cjs.HttpContentType; }
+  get: function () { return chunkDMNWPVVT_cjs.HttpContentType; }
 });
 Object.defineProperty(exports, "HttpHeader", {
   enumerable: true,
-  get: function () { return chunkIUN2ZSU3_cjs.HttpHeader; }
+  get: function () { return chunkDMNWPVVT_cjs.HttpHeader; }
 });
 Object.defineProperty(exports, "KeboolaHttpHeader", {
   enumerable: true,
-  get: function () { return chunkIUN2ZSU3_cjs.KeboolaHttpHeader; }
+  get: function () { return chunkDMNWPVVT_cjs.KeboolaHttpHeader; }
 });
 Object.defineProperty(exports, "createGenericFetchClient", {
   enumerable: true,
-  get: function () { return chunkIUN2ZSU3_cjs.createGenericFetchClient; }
+  get: function () { return chunkDMNWPVVT_cjs.createGenericFetchClient; }
 });
 Object.defineProperty(exports, "isAbortError", {
   enumerable: true,
-  get: function () { return chunkIUN2ZSU3_cjs.isAbortError; }
+  get: function () { return chunkDMNWPVVT_cjs.isAbortError; }
 });
 Object.defineProperty(exports, "isApiError", {
   enumerable: true,
-  get: function () { return chunkIUN2ZSU3_cjs.isApiError; }
+  get: function () { return chunkDMNWPVVT_cjs.isApiError; }
 });
 Object.defineProperty(exports, "isFetchClientError", {
   enumerable: true,
-  get: function () { return chunkIUN2ZSU3_cjs.isFetchClientError; }
+  get: function () { return chunkDMNWPVVT_cjs.isFetchClientError; }
 });
+exports.KeboolaError = KeboolaError;
+exports.KeboolaErrorType = KeboolaErrorType;
 exports.assert = assert;
 exports.coalesce = coalesce;
-exports.createApiClient = createApiClient;
+exports.createDerivedAsyncStore = createDerivedAsyncStore;
 exports.createDerivedStore = createDerivedStore;
-exports.createLiveProject = createLiveProject;
+exports.createKeboola = createKeboola;
+exports.createLegacyKeboola = createLegacyKeboola;
+exports.createLocalStorage = createLocalStorage;
 exports.createLoggingMiddleware = createLoggingMiddleware;
+exports.createMemoryStorage = createMemoryStorage;
+exports.createNullStorage = createNullStorage;
+exports.createPersistor = createPersistor;
 exports.createRetryMiddleware = createRetryMiddleware;
+exports.createSessionStorage = createSessionStorage;
 exports.createStore = createStore;
 exports.deepMerge = deepMerge;
+exports.isKeboolaError = isKeboolaError;
 exports.isStorageTokenMutatingRequest = isStorageTokenMutatingRequest;
 exports.shallowEqual = shallowEqual;
 //# sourceMappingURL=index.cjs.map