mitra-interactions-sdk 1.0.60-beta.2 → 1.0.60-beta.21

package/dist/index.js

@@ -107,9 +107,6 @@ async function doLogin(method, options) {
   autoConfigureFromLogin(response, authUrl, projectId);
   return response;
 }
-async function loginWithEmailMitra(options) {
-  return doLogin("email", options);
-}
 async function loginWithGoogleMitra(options) {
   return doLogin("google", options);
 }
@@ -163,102 +160,12 @@ async function refreshTokenSilently(authUrl, projectId) {
   })();
   return _refreshPromise;
 }
-var SILENT_TIMEOUT_MS = 2e4;
-var AUTH_READY_TYPE = "mitra-auth-ready";
-var AUTH_CREDENTIALS_TYPE = "mitra-auth-credentials";
-function openSilentAuthIframe(authUrl, projectId, credentials) {
-  return new Promise((resolve, reject) => {
-    const origin = getOriginFromUrl(authUrl);
-    const base = authUrl.endsWith("/") ? authUrl : authUrl + "/";
-    const separator = base.includes("?") ? "&" : "?";
-    let url = `${base}${separator}mode=silent&projectId=${encodeURIComponent(projectId)}`;
-    if (typeof window !== "undefined") {
-      url += `&originUrl=${encodeURIComponent(window.location.href)}`;
-    }
-    const iframe = document.createElement("iframe");
-    iframe.style.display = "none";
-    const timer = setTimeout(() => {
-      cleanup();
-      reject(new Error("Timeout na autentica\xE7\xE3o silenciosa"));
-    }, SILENT_TIMEOUT_MS);
-    function onMessage(event) {
-      var _a, _b, _c;
-      if (event.origin !== origin) return;
-      if (((_a = event.data) == null ? void 0 : _a.type) === AUTH_READY_TYPE) {
-        (_b = iframe.contentWindow) == null ? void 0 : _b.postMessage({
-          type: AUTH_CREDENTIALS_TYPE,
-          ...credentials
-        }, origin);
-        return;
-      }
-      if (((_c = event.data) == null ? void 0 : _c.type) !== AUTH_MESSAGE_TYPE) return;
-      cleanup();
-      if (event.data.success) {
-        resolve(event.data.data);
-      } else {
-        reject(new Error(event.data.error || "Erro na autentica\xE7\xE3o"));
-      }
-    }
-    function cleanup() {
-      window.removeEventListener("message", onMessage);
-      clearTimeout(timer);
-      if (iframe.parentNode) iframe.parentNode.removeChild(iframe);
-    }
-    window.addEventListener("message", onMessage);
-    iframe.src = url;
-    document.body.appendChild(iframe);
-  });
-}
-async function emailSignupMitra(options) {
-  const { authUrl, projectId } = resolveLoginOptions(options);
-  const result = await openSilentAuthIframe(authUrl, projectId, {
-    action: "signup",
-    name: options.name,
-    email: options.email,
-    password: options.password
-  });
-  if (!result.needsVerification) {
-    throw new Error("Resposta inesperada do signup");
-  }
-}
-async function emailVerifyCodeMitra(options) {
-  const { authUrl, projectId } = resolveLoginOptions(options);
-  const response = await openSilentAuthIframe(authUrl, projectId, {
-    action: "verifyCode",
-    email: options.email,
-    code: options.code,
-    password: options.password
-  });
-  autoConfigureFromLogin(response, authUrl, projectId);
-  return response;
-}
-async function emailResendCodeMitra(options) {
-  const { authUrl, projectId } = resolveLoginOptions(options);
-  await openSilentAuthIframe(authUrl, projectId, {
-    action: "resendCode",
-    email: options.email
-  });
-}
-async function emailLoginMitra(options) {
-  const { authUrl, projectId } = resolveLoginOptions(options);
-  const response = await openSilentAuthIframe(authUrl, projectId, {
-    action: "login",
-    email: options.email,
-    password: options.password
-  });
-  autoConfigureFromLogin(response, authUrl, projectId);
-  return response;
-}
 
 // src/auth-new.ts
 function getFetch() {
   if (typeof globalThis.fetch === "function") return globalThis.fetch;
   throw new Error("fetch n\xE3o dispon\xEDvel. Use Node.js 18+ ou instale node-fetch.");
 }
-function buildEndpoint(authUrl, path) {
-  const base = authUrl.replace(/\/+$/, "");
-  return `${base}/iam/api/v1/auth${path}`;
-}
 function buildBffAuthEndpoint(gateway, path) {
   const base = gateway.replace(/\/+$/, "");
   return `${base}/auth${path}`;
@@ -287,25 +194,6 @@ function autoConfigureFromLogin2(response, authUrl, projectId) {
     ...response.integrationURL ? { integrationURL: response.integrationURL } : {}
   });
 }
-async function postNewAuth(url, body) {
-  const fetchFn = getFetch();
-  const response = await fetchFn(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(body)
-  });
-  if (!response.ok) {
-    const text = await response.text().catch(() => "");
-    let parsed = null;
-    try {
-      parsed = text ? JSON.parse(text) : null;
-    } catch (e) {
-    }
-    const msg = (parsed == null ? void 0 : parsed.message) || (parsed == null ? void 0 : parsed.error) || `HTTP ${response.status}`;
-    throw { message: msg, status: response.status, details: parsed };
-  }
-  return response.json();
-}
 async function postBffAuth(url, body) {
   const fetchFn = getFetch();
   const response = await fetchFn(url, {
@@ -313,18 +201,14 @@ async function postBffAuth(url, body) {
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify(body)
   });
+  const text = await response.text().catch(() => "");
+  const { data, isJson } = parseBody(text);
   if (!response.ok) {
-    const text2 = await response.text().catch(() => "");
-    let parsed = null;
-    try {
-      parsed = text2 ? JSON.parse(text2) : null;
-    } catch (e) {
-    }
-    const msg = (parsed == null ? void 0 : parsed.message) || (parsed == null ? void 0 : parsed.error) || `HTTP ${response.status}`;
-    throw { message: msg, status: response.status, details: parsed };
+    const fallback = !isJson && text ? `HTTP ${response.status} \u2014 ${text}` : `HTTP ${response.status}`;
+    const msg = isJson && ((data == null ? void 0 : data.message) || (data == null ? void 0 : data.error)) || fallback;
+    throw { message: msg, status: response.status, details: data };
   }
-  const text = await response.text().catch(() => "");
-  return text ? JSON.parse(text) : null;
+  return data;
 }
 function normalizeResponse(tokens, authUrl) {
   return {
@@ -333,21 +217,89 @@ function normalizeResponse(tokens, authUrl) {
     baseURL: authUrl
   };
 }
-var NOT_SUPPORTED_POPUP = 'Login via popup (loginWithEmailMitra/loginMitra com method "email" ou "mitra") ainda n\xE3o suportado no novo Mitra. Use emailLoginMitra({ email, password }).';
-var NOT_SUPPORTED_VERIFY = "emailVerifyCodeMitra n\xE3o existe no novo Mitra (signup \xE9 direto, sem c\xF3digo de verifica\xE7\xE3o).";
-var NOT_SUPPORTED_RESEND = "emailResendCodeMitra n\xE3o existe no novo Mitra.";
-var NOT_SUPPORTED_REDIRECT = 'mode "redirect" ainda n\xE3o suportado no novo Mitra para SSO. Use mode "popup" (default).';
+var NOT_SUPPORTED_POPUP = 'loginMitra com method "email" ou "mitra" n\xE3o \xE9 suportado no novo Mitra. Use SSO (loginWithGoogleMitra).';
 var OAUTH_RESULT_TYPE = "mitra-oauth-result";
 var POPUP_W = 480;
 var POPUP_H = 600;
 var POPUP_TIMEOUT_MS = 5 * 60 * 1e3;
-var SSO_AUTH_PAGE_URL = "https://d2by6yrxhbu2rl.cloudfront.net/sdk-auth.html";
-async function fetchSsoAuthPageUrl(_baseURL) {
-  return SSO_AUTH_PAGE_URL;
+var SSO_AUTH_PAGE_URL = "https://stg.mitralab.io/sdk-auth.html";
+async function fetchSsoAuthPageUrl(gatewayUrl) {
+  const config = isConfigured() ? getConfig() : null;
+  if (config == null ? void 0 : config.authPageUrl) return config.authPageUrl;
+  try {
+    return `${new URL(gatewayUrl).origin}/sdk-auth.html`;
+  } catch (e) {
+    return SSO_AUTH_PAGE_URL;
+  }
+}
+var SSO_ENABLED_PROVIDERS = ["google"];
+function providerLabel(provider) {
+  return provider === "microsoft" ? "Microsoft" : provider === "google" ? "Google" : provider;
+}
+function assertProviderAvailable(provider) {
+  if (!SSO_ENABLED_PROVIDERS.includes(provider)) {
+    throw new Error(`Login com ${providerLabel(provider)} ainda n\xE3o dispon\xEDvel no novo Mitra.`);
+  }
+}
+function stripToOriginPath(url) {
+  try {
+    const u = new URL(url);
+    return u.origin + u.pathname;
+  } catch (e) {
+    return url.split("?")[0].split("#")[0];
+  }
+}
+async function exchangeSsoCode(authUrl, provider, code, redirectUri, projectId) {
+  const data = await postBffAuth(buildBffAuthEndpoint(authUrl, `/${provider}`), {
+    appId: String(projectId),
+    code,
+    redirectUri
+  });
+  const response = {
+    token: data.token,
+    // baseURL = authUrl (gateway); o BFF não devolve URLs de bootstrap.
+    baseURL: authUrl,
+    ...data.refreshToken ? { refreshToken: data.refreshToken } : {}
+  };
+  autoConfigureFromLogin2(response, authUrl, projectId);
+  return response;
+}
+var SSO_REDIRECT_STORE_KEY = "mitra_sso_redirect";
+function persistRedirectContext(ctx) {
+  try {
+    sessionStorage.setItem(SSO_REDIRECT_STORE_KEY, JSON.stringify(ctx));
+  } catch (e) {
+  }
+}
+function readRedirectContext() {
+  try {
+    const raw = sessionStorage.getItem(SSO_REDIRECT_STORE_KEY);
+    return raw ? JSON.parse(raw) : null;
+  } catch (e) {
+    return null;
+  }
+}
+function clearRedirectContext() {
+  try {
+    sessionStorage.removeItem(SSO_REDIRECT_STORE_KEY);
+  } catch (e) {
+  }
 }
-function buildStartUrl(authPageUrl, provider, state, appId, apiUrl) {
+function buildStartUrl(authPageUrl, provider, state, appId, apiUrl, returnTo) {
   const sep = authPageUrl.includes("?") ? "&" : "?";
-  return authPageUrl + sep + new URLSearchParams({ provider, state, appId, apiUrl }).toString();
+  const query = {
+    provider,
+    state,
+    appId,
+    apiUrl,
+    // origin = origin desta SDK; a página trava o postMessage do result nela.
+    origin: window.location.origin,
+    // Contrato novo: a página NÃO troca mais o code — devolve o code cru (popup
+    // via postMessage, redirect via #codeMitra). A SDK troca no BFF /auth/{provider}.
+    responseType: "code"
+  };
+  if (returnTo) query.returnTo = returnTo;
+  return authPageUrl + sep + new URLSearchParams(query).toString();
 }
 function getOriginFromUrl2(url) {
   try {
@@ -404,11 +356,11 @@ function openOAuthPopup(providerUrl, expectedOrigin, expectedState) {
         reject(new Error(data.error || "Erro na autentica\xE7\xE3o OAuth."));
         return;
       }
-      if (!data.code) {
-        reject(new Error("Resposta OAuth sem code."));
+      if (!data.code && !data.token) {
+        reject(new Error("Resposta OAuth sem code nem token."));
         return;
       }
-      resolve({ code: data.code });
+      resolve({ code: data.code, token: data.token });
     }
     function cleanup() {
       clearTimeout(timer);
@@ -421,13 +373,14 @@ function openOAuthPopup(providerUrl, expectedOrigin, expectedState) {
 }
 var _oauthInFlight = null;
 async function loginWithProvider(provider, options) {
-  if (_oauthInFlight) return _oauthInFlight;
+  assertProviderAvailable(provider);
   if (typeof window === "undefined") {
     throw new Error("SSO s\xF3 funciona em ambiente browser.");
   }
   if ((options == null ? void 0 : options.mode) === "redirect") {
-    throw new Error(NOT_SUPPORTED_REDIRECT);
+    return startSsoRedirect(provider, options);
   }
+  if (_oauthInFlight) return _oauthInFlight;
   _oauthInFlight = (async () => {
     try {
       const { authUrl, projectId } = resolveLoginOptions2(options);
@@ -435,15 +388,13 @@ async function loginWithProvider(provider, options) {
       const appId = String(projectId);
       const authPageUrl = await fetchSsoAuthPageUrl(authUrl);
       const pageOrigin = getOriginFromUrl2(authPageUrl);
-      const redirectUri = authPageUrl;
+      const redirectUri = stripToOriginPath(authPageUrl);
       const startUrl = buildStartUrl(authPageUrl, provider, state, appId, authUrl);
-      const { code } = await openOAuthPopup(startUrl, pageOrigin, state);
-      const tokens = await postNewAuth(buildEndpoint(authUrl, `/${provider}`), {
-        code,
-        redirectUri,
-        appId
-      });
-      const response = normalizeResponse(tokens, authUrl);
+      const { code, token } = await openOAuthPopup(startUrl, pageOrigin, state);
+      if (code) {
+        return await exchangeSsoCode(authUrl, provider, code, redirectUri, projectId);
+      }
+      const response = normalizeResponse(token, authUrl);
       autoConfigureFromLogin2(response, authUrl, projectId);
       return response;
     } finally {
@@ -452,8 +403,25 @@ async function loginWithProvider(provider, options) {
   })();
   return _oauthInFlight;
 }
-async function loginWithEmailMitra2(_options) {
-  throw new Error(NOT_SUPPORTED_POPUP);
+async function startSsoRedirect(provider, options) {
+  const { authUrl, projectId } = resolveLoginOptions2(options);
+  const state = generateState();
+  const appId = String(projectId);
+  const authPageUrl = await fetchSsoAuthPageUrl(authUrl);
+  const redirectUri = stripToOriginPath(authPageUrl);
+  persistRedirectContext({ state, provider, authUrl, projectId: appId, redirectUri });
+  const startUrl = buildStartUrl(authPageUrl, provider, state, appId, authUrl, window.location.href);
+  window.location.assign(startUrl);
+  return new Promise(() => {
+  });
+}
+async function exchangeSsoCodeMitra(options) {
+  const ctx = readRedirectContext();
+  clearRedirectContext();
+  if (!ctx || ctx.state !== options.state) {
+    throw new Error("State inv\xE1lido no retorno do SSO (poss\xEDvel CSRF).");
+  }
+  return exchangeSsoCode(ctx.authUrl, ctx.provider, options.code, ctx.redirectUri, ctx.projectId);
 }
 async function loginWithGoogleMitra2(options) {
   return loginWithProvider("google", options);
@@ -466,36 +434,6 @@ async function loginMitra2(method, options) {
   if (method === "microsoft") return loginWithProvider("microsoft", options);
   throw new Error(NOT_SUPPORTED_POPUP);
 }
-async function emailLoginMitra2(options) {
-  const { authUrl, projectId } = resolveLoginOptions2(options);
-  const data = await postBffAuth(buildBffAuthEndpoint(authUrl, "/email/login"), {
-    projectId: String(projectId),
-    email: options.email,
-    password: options.password
-  });
-  const response = {
-    token: data.token,
-    baseURL: data.baseURL || authUrl,
-    ...data.integrationURL ? { integrationURL: data.integrationURL } : {}
-  };
-  autoConfigureFromLogin2(response, authUrl, projectId);
-  return response;
-}
-async function emailSignupMitra2(options) {
-  const { authUrl, projectId } = resolveLoginOptions2(options);
-  await postBffAuth(buildBffAuthEndpoint(authUrl, "/email/signup"), {
-    projectId: String(projectId),
-    name: options.name,
-    email: options.email,
-    password: options.password
-  });
-}
-async function emailVerifyCodeMitra2(_options) {
-  throw new Error(NOT_SUPPORTED_VERIFY);
-}
-async function emailResendCodeMitra2(_options) {
-  throw new Error(NOT_SUPPORTED_RESEND);
-}
 var _refreshPromise2 = null;
 async function refreshTokenSilently2(authUrl, _projectId) {
   if (_refreshPromise2) return _refreshPromise2;
@@ -504,10 +442,15 @@ async function refreshTokenSilently2(authUrl, _projectId) {
       const config = isConfigured() ? getConfig() : null;
       const refreshToken = config == null ? void 0 : config.refreshToken;
       if (!refreshToken) {
-        throw new Error("refreshToken n\xE3o dispon\xEDvel para renova\xE7\xE3o no novo Mitra. Fa\xE7a login novamente.");
+        throw new Error("refreshToken n\xE3o dispon\xEDvel para renova\xE7\xE3o. Fa\xE7a login novamente.");
       }
-      const tokens = await postNewAuth(buildEndpoint(authUrl, "/refresh-token"), { refreshToken });
-      return normalizeResponse(tokens, authUrl);
+      const data = await postBffAuth(buildBffAuthEndpoint(authUrl, "/refresh-token"), { refreshToken });
+      return {
+        token: data.token,
+        // Refresh não muda a base — mantém o authUrl (gateway).
+        baseURL: authUrl,
+        ...data.refreshToken ? { refreshToken: data.refreshToken } : {}
+      };
     } finally {
       _refreshPromise2 = null;
     }
@@ -542,10 +485,6 @@ async function loginMitra3(method, options) {
   const authUrl = resolveAuthUrlFromOptions(options);
   return isLegacyAuthUrl(authUrl) ? loginMitra(method, options) : loginMitra2(method, options);
 }
-async function loginWithEmailMitra3(options) {
-  const authUrl = resolveAuthUrlFromOptions(options);
-  return isLegacyAuthUrl(authUrl) ? loginWithEmailMitra(options) : loginWithEmailMitra2();
-}
 async function loginWithGoogleMitra3(options) {
   const authUrl = resolveAuthUrlFromOptions(options);
   return isLegacyAuthUrl(authUrl) ? loginWithGoogleMitra(options) : loginWithGoogleMitra2(options);
@@ -554,1492 +493,63 @@ async function loginWithMicrosoftMitra3(options) {
   const authUrl = resolveAuthUrlFromOptions(options);
   return isLegacyAuthUrl(authUrl) ? loginWithMicrosoftMitra(options) : loginWithMicrosoftMitra2(options);
 }
-async function emailSignupMitra3(options) {
-  const authUrl = resolveAuthUrlFromOptions(options);
-  return isLegacyAuthUrl(authUrl) ? emailSignupMitra(options) : emailSignupMitra2(options);
-}
-async function emailLoginMitra3(options) {
-  const authUrl = resolveAuthUrlFromOptions(options);
-  return isLegacyAuthUrl(authUrl) ? emailLoginMitra(options) : emailLoginMitra2(options);
-}
-async function emailVerifyCodeMitra3(options) {
-  const authUrl = resolveAuthUrlFromOptions(options);
-  return isLegacyAuthUrl(authUrl) ? emailVerifyCodeMitra(options) : emailVerifyCodeMitra2();
-}
-async function emailResendCodeMitra3(options) {
-  const authUrl = resolveAuthUrlFromOptions(options);
-  return isLegacyAuthUrl(authUrl) ? emailResendCodeMitra(options) : emailResendCodeMitra2();
-}
 async function refreshTokenSilently3(authUrl, projectId) {
   return isLegacyAuthUrl(authUrl) ? refreshTokenSilently(authUrl, projectId) : refreshTokenSilently2(authUrl);
 }
-
-// src/chat.ts
-function openChatMitra() {
-  if (typeof window === "undefined") return;
-  const chat = window.__mitraChat;
-  if (!chat) return;
-  if (chat.isReady) {
-    chat.open();
-  } else {
-    const iv = setInterval(() => {
-      if (chat.isReady) {
-        clearInterval(iv);
-        chat.open();
-      }
-    }, 200);
-    setTimeout(() => clearInterval(iv), 15e3);
-  }
-}
-function closeChatMitra() {
-  var _a;
-  if (typeof window === "undefined") return;
-  (_a = window.__mitraChat) == null ? void 0 : _a.close();
+async function exchangeSsoCodeMitra2(options) {
+  return exchangeSsoCodeMitra(options);
 }
 
-// src/password-reset.ts
-var AUTH_API_BY_AUTH_URL = {
-  "https://coder.mitralab.io/sdk-auth/": "https://api0.mitraecp.com:1005",
-  "https://agent.mitralab.io/sdk-auth/": "https://api2.mitrasheet.com:4133"
-};
-function normalizeAuthUrl(url) {
-  const stripped = url.split("?")[0].split("#")[0];
-  return stripped.endsWith("/") ? stripped : stripped + "/";
-}
-var NOT_SUPPORTED_SEND = "sendPasswordResetCodeMitra ainda n\xE3o suportado no novo Mitra.";
-var NOT_SUPPORTED_VALIDATE = "validatePasswordResetCodeMitra ainda n\xE3o suportado no novo Mitra.";
-var NOT_SUPPORTED_RESET = "resetPasswordMitra ainda n\xE3o suportado no novo Mitra.";
-function isNewWorld2(opts) {
-  var _a;
-  if (opts.authApiURL) return false;
-  if (typeof window !== "undefined" && ((_a = window.__mitraEnv) == null ? void 0 : _a.apiBaseURL)) return false;
-  const authUrl = opts.authUrl || (isConfigured() ? getConfig().authUrl : void 0);
-  if (!authUrl) return false;
-  return !(normalizeAuthUrl(authUrl) in AUTH_API_BY_AUTH_URL);
-}
-function resolveProjectId(opts) {
-  if (opts.projectId != null) return opts.projectId;
-  if (isConfigured()) {
-    const pid = getConfig().projectId;
-    if (pid != null) return pid;
-  }
-  throw new Error(
-    "projectId \xE9 obrigat\xF3rio. Passe nas options ou configure via configureSdkMitra({ projectId })."
-  );
-}
-function resolveAuthApiURL(opts) {
-  var _a;
-  if (opts.authApiURL) return opts.authApiURL.replace(/\/+$/, "");
-  if (typeof window !== "undefined") {
-    const injected = (_a = window.__mitraEnv) == null ? void 0 : _a.apiBaseURL;
-    if (typeof injected === "string" && injected.length > 0) {
-      return injected.replace(/\/+$/, "");
-    }
-  }
-  const authUrl = opts.authUrl || (isConfigured() ? getConfig().authUrl : void 0);
-  if (authUrl) {
-    const apiURL = AUTH_API_BY_AUTH_URL[normalizeAuthUrl(authUrl)];
-    if (apiURL) return apiURL;
-  }
-  throw new Error(
-    "N\xE3o foi poss\xEDvel resolver a API base. Configure window.__mitraEnv.apiBaseURL via build-proxy, passe authApiURL nas options, ou use um authUrl conhecido (coder.mitralab.io ou agent.mitralab.io)."
-  );
+// src/instance.ts
+function formatToken(token) {
+  return `Bearer ${stripBearer(token)}`;
 }
 function getFetch2() {
   if (typeof globalThis.fetch === "function") return globalThis.fetch;
   throw new Error("fetch n\xE3o dispon\xEDvel. Use Node.js 18+ ou instale node-fetch.");
 }
-async function callAuthApi(url, method, body) {
-  const fetchFn = getFetch2();
-  const response = await fetchFn(url, {
-    method,
-    headers: { "Content-Type": "application/json", accept: "application/json" },
-    body: JSON.stringify(body)
-  });
-  const text = await response.text();
-  let data = null;
-  try {
-    data = text ? JSON.parse(text) : null;
-  } catch (e) {
-  }
-  if (!response.ok) {
-    const msg = (data == null ? void 0 : data.message) || (data == null ? void 0 : data.error) || `HTTP ${response.status}`;
-    throw { message: msg, status: response.status, details: data };
-  }
-  return data;
-}
-async function sendPasswordResetCodeMitra(options) {
-  if (isNewWorld2(options)) throw new Error(NOT_SUPPORTED_SEND);
-  const apiURL = resolveAuthApiURL(options);
-  const projectId = resolveProjectId(options);
-  return callAuthApi(`${apiURL}/mitraspace/auth/resetPassword`, "POST", {
-    email: options.email,
-    projectId
-  });
-}
-async function validatePasswordResetCodeMitra(options) {
-  if (isNewWorld2(options)) throw new Error(NOT_SUPPORTED_VALIDATE);
-  const apiURL = resolveAuthApiURL(options);
-  const projectId = resolveProjectId(options);
-  return callAuthApi(`${apiURL}/mitraspace/auth/resetPassword/validateCode`, "POST", {
-    email: options.email,
-    code: options.code,
-    projectId
-  });
-}
-async function resetPasswordMitra(options) {
-  if (isNewWorld2(options)) throw new Error(NOT_SUPPORTED_RESET);
-  const apiURL = resolveAuthApiURL(options);
-  const projectId = resolveProjectId(options);
-  return callAuthApi(`${apiURL}/mitraspace/auth/resetPassword`, "PUT", {
-    email: options.email,
-    code: options.code,
-    newPassword: options.newPassword,
-    projectId
-  });
+function buildQuery(params) {
+  return Object.entries(params).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&");
 }
-
-// src/client.ts
-function getFetch3() {
-  if (typeof globalThis.fetch === "function") {
-    return globalThis.fetch;
+function createMitraInstance(initialConfig) {
+  var _a;
+  let _config = {
+    baseURL: ((_a = initialConfig.baseURL) == null ? void 0 : _a.replace(/\/+$/, "")) || "",
+    token: initialConfig.token ? stripBearer(initialConfig.token) : "",
+    refreshToken: initialConfig.refreshToken,
+    integrationURL: initialConfig.integrationURL,
+    authUrl: initialConfig.authUrl,
+    projectId: initialConfig.projectId
+  };
+  function resolveProjectId2(projectId) {
+    if (projectId != null) return projectId;
+    if (_config.projectId != null) return _config.projectId;
+    throw new Error("projectId \xE9 obrigat\xF3rio. Passe nas options ou configure via configureSdkMitra({ projectId }).");
   }
-  throw new Error("fetch n\xE3o dispon\xEDvel. Use Node.js 18+ ou instale node-fetch.");
-}
-function formatToken(token) {
-  return `Bearer ${stripBearer(token)}`;
-}
-function buildHeaders() {
-  const config = getConfig();
-  const headers = { "Content-Type": "application/json" };
-  if (config.token) headers["Authorization"] = formatToken(config.token);
-  return headers;
-}
-function buildUrl(endpoint, params) {
-  const config = getConfig();
-  let url = `${config.baseURL}${endpoint}`;
-  if (params) {
-    const query = Object.entries(params).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&");
-    if (query) url += `?${query}`;
+  function authHeaders() {
+    const headers = { "Content-Type": "application/json" };
+    if (_config.token) headers["Authorization"] = formatToken(_config.token);
+    return headers;
   }
-  return url;
-}
-async function tryRefreshToken() {
-  var _a, _b;
-  const config = getConfig();
-  if (!config.token || config.projectId == null) return false;
-  try {
-    const baseURL = config.baseURL.replace(/\/+$/, "");
-    const resp = await getFetch3()(`${baseURL}/mitraspace/project/refreshedToken/${config.projectId}`, {
-      method: "GET",
-      headers: { "Authorization": formatToken(config.token) }
-    });
-    if (resp.ok) {
-      const data = await resp.json();
-      if (data.token) {
-        const newToken = `Bearer ${stripBearer(data.token)}`;
-        const session = {
-          token: newToken,
-          baseURL: ((_a = data.merge) == null ? void 0 : _a.backURL) || config.baseURL,
-          ...((_b = data.merge) == null ? void 0 : _b.integrationURL) ? { integrationURL: data.merge.integrationURL } : {}
-        };
-        updateGlobalToken(session.token);
-        if (config.onTokenRefresh) config.onTokenRefresh(session);
-        return true;
-      }
+  async function handleResponse2(response) {
+    const text = await response.text();
+    const { data, isJson } = parseBody(text);
+    if (!response.ok) {
+      const fallback = !isJson && text ? `HTTP ${response.status} \u2014 ${text}` : `HTTP ${response.status}`;
+      const base = isJson && ((data == null ? void 0 : data.message) || (data == null ? void 0 : data.error)) || fallback;
+      const msg = isJson && (data == null ? void 0 : data.hint) ? `${base} \u2014 ${data.hint}` : base;
+      throw { message: msg, status: response.status, details: data };
     }
-  } catch (e) {
-  }
-  if (!config.authUrl || typeof window === "undefined") return false;
-  try {
-    const session = await refreshTokenSilently3(config.authUrl, config.projectId);
-    updateGlobalToken(session.token, session.refreshToken);
-    if (config.onTokenRefresh) config.onTokenRefresh(session);
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-async function handleResponse(response) {
-  const text = await response.text();
-  const data = text ? JSON.parse(text) : null;
-  if (!response.ok) {
-    const base = (data == null ? void 0 : data.message) || (data == null ? void 0 : data.error) || `HTTP ${response.status}`;
-    const msg = (data == null ? void 0 : data.hint) ? `${base} \u2014 ${data.hint}` : base;
-    throw {
-      message: msg,
-      status: response.status,
-      details: data
-    };
-  }
-  return data;
-}
-async function fetchWithRefresh(url, init) {
-  const fetchFn = getFetch3();
-  const response = await fetchFn(url, init);
-  if (response.status === 403) {
-    const refreshed = await tryRefreshToken();
-    if (refreshed) {
-      const newHeaders = { ...buildHeaders() };
-      const oldHeaders = init.headers;
-      if (oldHeaders) {
-        for (const [k, v] of Object.entries(oldHeaders)) {
-          if (k !== "Authorization") newHeaders[k] = v;
-        }
-      }
-      const retryResponse = await fetchFn(url, { ...init, headers: newHeaders });
-      return handleResponse(retryResponse);
-    }
-  }
-  return handleResponse(response);
-}
-var http = {
-  async get(endpoint, params) {
-    return fetchWithRefresh(buildUrl(endpoint, params), {
-      method: "GET",
-      headers: buildHeaders()
-    });
-  },
-  async post(endpoint, body) {
-    return fetchWithRefresh(buildUrl(endpoint), {
-      method: "POST",
-      headers: buildHeaders(),
-      body: body !== void 0 ? JSON.stringify(body) : void 0
-    });
-  },
-  async put(endpoint, body) {
-    return fetchWithRefresh(buildUrl(endpoint), {
-      method: "PUT",
-      headers: buildHeaders(),
-      body: body !== void 0 ? JSON.stringify(body) : void 0
-    });
-  },
-  async del(endpoint, params) {
-    return fetchWithRefresh(buildUrl(endpoint, params), {
-      method: "DELETE",
-      headers: buildHeaders()
-    });
-  },
-  async delBody(endpoint, body) {
-    return fetchWithRefresh(buildUrl(endpoint), {
-      method: "DELETE",
-      headers: buildHeaders(),
-      body: body !== void 0 ? JSON.stringify(body) : void 0
-    });
-  },
-  async upload(endpoint, formData) {
-    const config = getConfig();
-    const headers = {};
-    if (config.token) headers["Authorization"] = formatToken(config.token);
-    return fetchWithRefresh(buildUrl(endpoint), {
-      method: "POST",
-      headers,
-      body: formData
-    });
-  }
-};
-async function requestWithTenant(method, endpoint, tenantId, options) {
-  const headers = {
-    ...buildHeaders(),
-    "X-TenantID": String(tenantId)
-  };
-  return fetchWithRefresh(buildUrl(endpoint, options == null ? void 0 : options.params), {
-    method,
-    headers,
-    body: (options == null ? void 0 : options.body) !== void 0 ? JSON.stringify(options.body) : void 0
-  });
-}
-var httpTenant = {
-  get(endpoint, tenantId, params) {
-    return requestWithTenant("GET", endpoint, tenantId, { params });
-  },
-  post(endpoint, tenantId, body, params) {
-    return requestWithTenant("POST", endpoint, tenantId, { body, params });
-  },
-  put(endpoint, tenantId, body, params) {
-    return requestWithTenant("PUT", endpoint, tenantId, { body, params });
-  },
-  patch(endpoint, tenantId, body, params) {
-    return requestWithTenant("PATCH", endpoint, tenantId, { body, params });
-  },
-  del(endpoint, tenantId, params) {
-    return requestWithTenant("DELETE", endpoint, tenantId, { params });
-  }
-};
-
-// src/services.ts
-async function executeDataLoaderMitra(options) {
-  const body = {
-    projectId: resolveProjectId2(options.projectId),
-    dataLoaderId: options.dataLoaderId
-  };
-  if (options.input !== void 0) body.input = options.input;
-  return http.post("/interactions/executeDataLoader", body);
-}
-async function executeDbActionMitra(options) {
-  const body = {
-    projectId: resolveProjectId2(options.projectId),
-    dbActionId: options.dbActionId
-  };
-  if (options.input !== void 0) {
-    body.input = options.input;
-  }
-  return http.post("/interactions/executeDbAction", body);
-}
-async function setFileStatusMitra(options) {
-  return http.post("/interactions/setFileStatus", {
-    projectId: resolveProjectId2(options.projectId),
-    fileName: options.fileName,
-    targetPath: options.targetPath
-  });
-}
-async function setVariableMitra(options) {
-  const body = {
-    projectId: resolveProjectId2(options.projectId),
-    key: options.key
-  };
-  if (options.value !== void 0) {
-    body.value = options.value;
-  }
-  return http.post("/interactions/setVariable", body);
-}
-async function listVariablesMitra(options = {}) {
-  return http.get("/interactions/listVariables", {
-    projectId: resolveProjectId2(options.projectId)
-  });
-}
-async function getVariableMitra(options) {
-  return http.get("/interactions/getVariable", {
-    projectId: resolveProjectId2(options.projectId),
-    key: options.key
-  });
-}
-async function runActionMitra(options) {
-  const body = {
-    projectId: resolveProjectId2(options.projectId),
-    actionId: options.actionId
-  };
-  if (options.input !== void 0) {
-    body.input = options.input;
-  }
-  return http.post("/interactions/runAction", body);
-}
-async function executeServerFunctionMitra(options) {
-  const body = {
-    projectId: resolveProjectId2(options.projectId),
-    serverFunctionId: options.serverFunctionId
-  };
-  if (options.input !== void 0) {
-    body.input = options.input;
-  }
-  return http.post("/interactions/executeServerFunction", body);
-}
-async function executeServerFunctionAsyncMitra(options) {
-  const body = {
-    projectId: resolveProjectId2(options.projectId),
-    serverFunctionId: options.serverFunctionId
-  };
-  if (options.input !== void 0) {
-    body.input = options.input;
-  }
-  return http.post("/interactions/executeServerFunctionAsync", body);
-}
-async function executePublicServerFunctionMitra(options) {
-  const { projectId, serverFunctionId, input } = options;
-  const baseURL = getConfig().baseURL;
-  const url = `${baseURL}/public/serverFunction/${projectId}/${serverFunctionId}/execute`;
-  const response = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(input || {})
-  });
-  if (!response.ok) {
-    const data = await response.json().catch(() => null);
-    const msg = (data == null ? void 0 : data.message) || (data == null ? void 0 : data.error) || `HTTP ${response.status}`;
-    throw { message: msg, status: response.status, details: data };
-  }
-  return response.json();
-}
-async function executePublicServerFunctionAsyncMitra(options) {
-  const { projectId, serverFunctionId, input } = options;
-  const baseURL = getConfig().baseURL;
-  const url = `${baseURL}/public/serverFunction/${projectId}/${serverFunctionId}/executeAsync`;
-  const response = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(input || {})
-  });
-  if (!response.ok) {
-    const data = await response.json().catch(() => null);
-    const msg = (data == null ? void 0 : data.message) || (data == null ? void 0 : data.error) || `HTTP ${response.status}`;
-    throw { message: msg, status: response.status, details: data };
-  }
-  return response.json();
-}
-async function getPublicServerFunctionExecutionMitra(options) {
-  const { projectId, executionId } = options;
-  const baseURL = getConfig().baseURL;
-  const url = `${baseURL}/public/serverFunction/${projectId}/execution/${executionId}`;
-  const response = await fetch(url, {
-    method: "GET",
-    headers: { "Content-Type": "application/json" }
-  });
-  if (!response.ok) {
-    const data = await response.json().catch(() => null);
-    const msg = (data == null ? void 0 : data.message) || (data == null ? void 0 : data.error) || `HTTP ${response.status}`;
-    throw { message: msg, status: response.status, details: data };
-  }
-  return response.json();
-}
-async function listIntegrationsMitra(options = {}) {
-  return http.get("/interactions/integrations", {
-    projectId: resolveProjectId2(options.projectId)
-  });
-}
-async function callIntegrationMitra(options) {
-  const body = {
-    integrationSlug: options.connection,
-    projectId: resolveProjectId2(options.projectId),
-    method: options.method
-  };
-  if (options.endpoint !== void 0) {
-    body.endpoint = options.endpoint;
-  }
-  if (options.params !== void 0) {
-    body.params = options.params;
-  }
-  if (options.body !== void 0) {
-    body.body = options.body;
-  }
-  return http.post("/interactions/integrations/call", body);
-}
-async function stopServerFunctionExecutionMitra(options) {
-  return http.post("/interactions/stopServerFunctionExecution", {
-    projectId: resolveProjectId2(options.projectId),
-    executionId: options.executionId
-  });
-}
-async function uploadFilePublicMitra(options) {
-  const formData = new FormData();
-  formData.append("file", options.file);
-  formData.append("projectId", String(resolveProjectId2(options.projectId)));
-  if (options.debug !== void 0) formData.append("debug", String(options.debug));
-  return http.upload("/interactions/uploadFilePublic", formData);
-}
-async function uploadFileLoadableMitra(options) {
-  const formData = new FormData();
-  formData.append("file", options.file);
-  formData.append("projectId", String(resolveProjectId2(options.projectId)));
-  if (options.debug !== void 0) formData.append("debug", String(options.debug));
-  return http.upload("/interactions/uploadFileLoadable", formData);
-}
-async function listRecordsMitra(options) {
-  const { tableName, page, size, filters, jdbcConnectionConfigId } = options;
-  const pid = resolveProjectId2(options.projectId);
-  return httpTenant.get(`/interactions/records/${tableName}`, pid, { page, size, jdbcConnectionConfigId, ...filters });
-}
-async function getRecordMitra(options) {
-  const { tableName, id, jdbcConnectionConfigId } = options;
-  const pid = resolveProjectId2(options.projectId);
-  return httpTenant.get(`/interactions/records/${tableName}/${id}`, pid, { jdbcConnectionConfigId });
-}
-async function createRecordMitra(options) {
-  const { tableName, data, jdbcConnectionConfigId } = options;
-  const pid = resolveProjectId2(options.projectId);
-  return httpTenant.post(`/interactions/records/${tableName}`, pid, data, { jdbcConnectionConfigId });
-}
-async function updateRecordMitra(options) {
-  const { tableName, id, data, jdbcConnectionConfigId } = options;
-  const pid = resolveProjectId2(options.projectId);
-  return httpTenant.put(`/interactions/records/${tableName}/${id}`, pid, data, { jdbcConnectionConfigId });
-}
-async function patchRecordMitra(options) {
-  const { tableName, id, data, jdbcConnectionConfigId } = options;
-  const pid = resolveProjectId2(options.projectId);
-  return httpTenant.patch(`/interactions/records/${tableName}/${id}`, pid, data, { jdbcConnectionConfigId });
-}
-async function deleteRecordMitra(options) {
-  const { tableName, id, jdbcConnectionConfigId } = options;
-  const pid = resolveProjectId2(options.projectId);
-  return httpTenant.del(`/interactions/records/${tableName}/${id}`, pid, { jdbcConnectionConfigId });
-}
-async function createRecordsBatchMitra(options) {
-  const { tableName, records, jdbcConnectionConfigId } = options;
-  const pid = resolveProjectId2(options.projectId);
-  return httpTenant.post(`/interactions/records/${tableName}/batch`, pid, records, { jdbcConnectionConfigId });
-}
-async function listProfilesMitra(options = {}) {
-  return http.get("/interactions/profiles", { projectId: resolveProjectId2(options.projectId) });
-}
-async function getProfileDetailsMitra(options) {
-  return http.get(`/interactions/profiles/${options.profileId}`, { projectId: resolveProjectId2(options.projectId) });
-}
-async function createProfileMitra(options) {
-  const body = {
-    projectId: resolveProjectId2(options.projectId),
-    name: options.name
-  };
-  if (options.color !== void 0) body.color = options.color;
-  if (options.homeScreenId !== void 0) body.homeScreenId = options.homeScreenId;
-  return http.post("/interactions/profiles", body);
-}
-async function updateProfileMitra(options) {
-  const body = {
-    projectId: resolveProjectId2(options.projectId),
-    profileId: options.profileId
-  };
-  if (options.name !== void 0) body.name = options.name;
-  if (options.color !== void 0) body.color = options.color;
-  if (options.homeScreenId !== void 0) body.homeScreenId = options.homeScreenId;
-  return http.put("/interactions/profiles", body);
-}
-async function deleteProfileMitra(options) {
-  return http.delBody("/interactions/profiles", {
-    projectId: resolveProjectId2(options.projectId),
-    profileId: options.profileId
-  });
-}
-async function setProfileUsersMitra(options) {
-  return http.post("/interactions/profiles/users", {
-    projectId: resolveProjectId2(options.projectId),
-    profileId: options.profileId,
-    userIds: options.userIds
-  });
-}
-async function setProfileSelectTablesMitra(options) {
-  const body = {
-    projectId: resolveProjectId2(options.projectId),
-    profileId: options.profileId,
-    tables: options.tables
-  };
-  if (options.jdbcConnectionConfigId !== void 0) body.jdbcConnectionConfigId = options.jdbcConnectionConfigId;
-  return http.post("/interactions/profiles/selectTables", body);
-}
-async function setProfileDmlTablesMitra(options) {
-  const body = {
-    projectId: resolveProjectId2(options.projectId),
-    profileId: options.profileId,
-    tables: options.tables
-  };
-  if (options.jdbcConnectionConfigId !== void 0) body.jdbcConnectionConfigId = options.jdbcConnectionConfigId;
-  return http.post("/interactions/profiles/dmlTables", body);
-}
-async function setProfileActionsMitra(options) {
-  return http.post("/interactions/profiles/actions", {
-    projectId: resolveProjectId2(options.projectId),
-    profileId: options.profileId,
-    actionIds: options.actionIds
-  });
-}
-async function setProfileScreensMitra(options) {
-  return http.post("/interactions/profiles/screens", {
-    projectId: resolveProjectId2(options.projectId),
-    profileId: options.profileId,
-    screenIds: options.screenIds
-  });
-}
-async function setProfileServerFunctionsMitra(options) {
-  return http.post("/interactions/profiles/serverFunctions", {
-    projectId: resolveProjectId2(options.projectId),
-    profileId: options.profileId,
-    serverFunctionIds: options.serverFunctionIds
-  });
-}
-
-// src/agent-attachments.ts
-var EXTENSION_MAP = {
-  // Images
-  png: "image",
-  jpg: "image",
-  jpeg: "image",
-  gif: "image",
-  webp: "image",
-  svg: "image",
-  bmp: "image",
-  ico: "image",
-  // PDF
-  pdf: "pdf",
-  // CSV
-  csv: "csv",
-  tsv: "csv",
-  // Excel
-  xlsx: "excel",
-  xls: "excel",
-  xlsm: "excel",
-  xlsb: "excel",
-  ods: "excel",
-  // Word
-  docx: "word",
-  doc: "word",
-  odt: "word",
-  rtf: "word",
-  // PowerPoint
-  pptx: "powerpoint",
-  ppt: "powerpoint",
-  odp: "powerpoint",
-  // Text
-  txt: "text",
-  md: "text",
-  log: "text",
-  ini: "text",
-  cfg: "text",
-  env: "text",
-  // Code
-  js: "code",
-  ts: "code",
-  jsx: "code",
-  tsx: "code",
-  py: "code",
-  rb: "code",
-  java: "code",
-  c: "code",
-  cpp: "code",
-  h: "code",
-  cs: "code",
-  go: "code",
-  rs: "code",
-  php: "code",
-  swift: "code",
-  kt: "code",
-  scala: "code",
-  html: "code",
-  css: "code",
-  scss: "code",
-  less: "code",
-  sql: "code",
-  sh: "code",
-  bash: "code",
-  zsh: "code",
-  yaml: "code",
-  yml: "code",
-  toml: "code",
-  xml: "code",
-  vue: "code",
-  svelte: "code",
-  // JSON
-  json: "json",
-  jsonl: "json",
-  geojson: "json",
-  // ZIP
-  zip: "zip",
-  tar: "zip",
-  gz: "zip",
-  rar: "zip",
-  "7z": "zip",
-  // Audio
-  mp3: "audio",
-  wav: "audio",
-  ogg: "audio",
-  flac: "audio",
-  m4a: "audio",
-  aac: "audio",
-  wma: "audio"
-};
-function detectAttachmentType(file) {
-  var _a, _b;
-  const ext = (_b = (_a = file.name.split(".").pop()) == null ? void 0 : _a.toLowerCase()) != null ? _b : "";
-  if (EXTENSION_MAP[ext]) return EXTENSION_MAP[ext];
-  if (file.type.startsWith("image/")) return "image";
-  if (file.type === "application/pdf") return "pdf";
-  if (file.type.startsWith("audio/")) return "audio";
-  if (file.type.startsWith("text/")) return "text";
-  return "unknown";
-}
-async function buildAttachmentsFromFiles(files, projectId) {
-  return Promise.all(
-    files.map(async (file) => {
-      var _a;
-      const type = detectAttachmentType(file);
-      const res = await uploadFilePublicMitra({ file, projectId });
-      const url = (_a = res.result) == null ? void 0 : _a.publicUrl;
-      if (!url) {
-        throw new Error(`upload sem URL p\xFAblica: ${file.name}`);
-      }
-      return {
-        url,
-        name: file.name,
-        type,
-        mimeType: file.type,
-        size: file.size
-      };
-    })
-  );
-}
-
-// src/agent-task-session.ts
-var QUEUE_MAX = 10;
-var TURN_STARTED_SAFETY_MS = 3e4;
-var sessionCounter = 0;
-var AgentTaskSession = class {
-  constructor(init, transport2) {
-    // ── Identidade ────────────────────────
-    this._taskId = null;
-    this._task = null;
-    // ── Estado ────────────────────────────
-    this._status = "opening";
-    this._history = [];
-    this._content = "";
-    this._queue = [];
-    // ── Cancel state ──────────────────────
-    this._cancelled = false;
-    this._awaitingTurnStarted = false;
-    this._turnStartedTimer = null;
-    this._pendingCancelResolve = null;
-    // ── Listeners ─────────────────────────
-    this._listeners = /* @__PURE__ */ new Map();
-    this._wsUnsubscribe = null;
-    this._wsUnsubscribePending = null;
-    this._transport = transport2;
-    this._sessionId = `sess-${++sessionCounter}-${Date.now()}`;
-    this._isNew = init.kind === "new";
-    if (init.kind === "new") {
-      this._projectId = init.projectId;
-      this._agentType = init.agentType;
-      this._modelId = init.modelId;
-      this._initialName = init.name;
-      this._setStatus("idle");
-      this._wsUnsubscribePending = this._transport.subscribePending(
-        this._sessionId,
-        (msg) => this._handleMessage(msg)
-      );
-    } else {
-      this._taskId = init.taskId;
-      this._transport.register(init.taskId, this);
-      this._wsUnsubscribe = this._transport.subscribe(
-        init.taskId,
-        (msg) => this._handleMessage(msg)
-      );
-      this._initExisting(init.taskId);
-    }
-  }
-  // ── Properties públicas ────────────────────────────
-  get taskId() {
-    return this._taskId;
-  }
-  get task() {
-    return this._task;
-  }
-  get isNew() {
-    return this._isNew;
-  }
-  get status() {
-    return this._status;
-  }
-  get history() {
-    return this._history;
-  }
-  get content() {
-    return this._content;
-  }
-  get queue() {
-    return this._queue;
-  }
-  // ── Lifecycle ──────────────────────────────────────
-  async _initExisting(taskId) {
-    try {
-      await this._transport.ensureConnected();
-      if (this._status === "closed") return;
-      if (this._transport.isStreaming(taskId)) {
-        this._setStatus("streaming");
-      } else {
-        this._setStatus("idle");
-      }
-    } catch (err) {
-      this._emitError(err instanceof Error ? err.message : String(err));
-    }
-  }
-  async loadHistory(options) {
-    if (this._status === "closed") {
-      throw new Error("AgentTaskSession: session fechada.");
-    }
-    if (!this._taskId) {
-      this._history = [];
-      this._emit("historyLoaded", []);
-      return [];
-    }
-    await this._transport.ensureConnected();
-    const payload = { taskId: this._taskId };
-    if ((options == null ? void 0 : options.limit) != null) payload.limit = options.limit;
-    const msgs = await this._transport.request("get_history", payload);
-    this._history = msgs;
-    this._emit("historyLoaded", msgs);
-    return msgs;
-  }
-  close() {
-    if (this._status === "closed") return;
-    this._setStatus("closed");
-    if (this._turnStartedTimer) {
-      clearTimeout(this._turnStartedTimer);
-      this._turnStartedTimer = null;
-    }
-    if (this._wsUnsubscribe) {
-      this._wsUnsubscribe();
-      this._wsUnsubscribe = null;
-    }
-    if (this._wsUnsubscribePending) {
-      this._wsUnsubscribePending();
-      this._wsUnsubscribePending = null;
-    }
-    this._transport.unregister(this._taskId, this._sessionId);
-    this._listeners.clear();
-  }
-  // ── Comandos ───────────────────────────────────────
-  send(prompt, options) {
-    var _a, _b, _c, _d;
-    if (this._status === "closed") {
-      throw new Error("AgentTaskSession: session fechada.");
-    }
-    const files = ((_a = options == null ? void 0 : options.files) == null ? void 0 : _a.length) ? options.files : void 0;
-    if (!prompt.trim() && !files) return;
-    const agentType = (_c = (_b = options == null ? void 0 : options.agentType) != null ? _b : this._agentType) != null ? _c : "claudecode";
-    const modelId = (_d = options == null ? void 0 : options.modelId) != null ? _d : this._modelId;
-    if (files) {
-      void this._uploadThenDispatch(prompt, agentType, modelId, files);
-      return;
-    }
-    this._dispatchSend(prompt, agentType, modelId, void 0);
-  }
-  async _uploadThenDispatch(prompt, agentType, modelId, files) {
-    const wasStreaming = this._status === "streaming";
-    if (!wasStreaming) this._setStatus("uploading");
-    let attachments;
-    try {
-      attachments = await buildAttachmentsFromFiles(files, this._projectId);
-    } catch (err) {
-      this._emit("error", {
-        error: `Falha ao subir anexos: ${err instanceof Error ? err.message : String(err)}`
-      });
-      if (this._status === "uploading") this._setStatus("idle");
-      return;
-    }
-    if (this._status === "closed") return;
-    this._dispatchSend(prompt, agentType, modelId, attachments);
-  }
-  _dispatchSend(prompt, agentType, modelId, attachments) {
-    var _a;
-    if (this._status === "streaming") {
-      this._enqueue(prompt, agentType);
-      if (this._taskId) {
-        this._transport.send(
-          "send_prompt",
-          {
-            prompt,
-            taskId: this._taskId,
-            projectId: this._projectId,
-            agentType,
-            ...modelId ? { modelId } : {},
-            ...attachments ? { attachments } : {},
-            midSession: true
-          },
-          this._taskId
-        );
-      }
-      return;
-    }
-    if (this._status === "cancelled") {
-      this._awaitingTurnStarted = true;
-      if (this._turnStartedTimer) clearTimeout(this._turnStartedTimer);
-      this._turnStartedTimer = setTimeout(() => {
-        this._turnStartedTimer = null;
-        if (this._awaitingTurnStarted) {
-          this._cancelled = false;
-          this._awaitingTurnStarted = false;
-          this._setStatus("idle");
-        }
-      }, TURN_STARTED_SAFETY_MS);
-    }
-    this._setStatus("streaming");
-    this._content = "";
-    const payload = {
-      prompt,
-      projectId: this._projectId,
-      agentType
-    };
-    if (modelId) payload.modelId = modelId;
-    if (attachments) payload.attachments = attachments;
-    if (this._taskId) payload.taskId = this._taskId;
-    if (this._initialName && !this._taskId) {
-      payload.name = this._initialName;
-    }
-    this._transport.send("send_prompt", payload, (_a = this._taskId) != null ? _a : void 0);
-  }
-  async cancel() {
-    if (this._status === "closed") return;
-    if (this._status !== "streaming" && this._status !== "cancelled") return;
-    this._cancelled = true;
-    this._clearQueue();
-    if (this._taskId) {
-      this._transport.send(
-        "task_cancel",
-        { source: "sdk_cancel" },
-        this._taskId
-      );
-    }
-    this._setStatus("cancelled");
-    this._emit("cancelled", void 0);
-    return new Promise((resolve) => {
-      const previousResolve = this._pendingCancelResolve;
-      this._pendingCancelResolve = () => {
-        resolve();
-        if (previousResolve) previousResolve();
-      };
-      setTimeout(() => {
-        if (this._pendingCancelResolve) {
-          this._pendingCancelResolve = null;
-          resolve();
-        }
-      }, TURN_STARTED_SAFETY_MS);
-    });
-  }
-  // ── Manipulação de fila ────────────────────────────
-  editQueueItem(itemId, newText) {
-    const idx = this._queue.findIndex((q) => q.id === itemId);
-    if (idx < 0 || this._queue[idx].status !== "pending") return false;
-    this._queue = [
-      ...this._queue.slice(0, idx),
-      { ...this._queue[idx], text: newText },
-      ...this._queue.slice(idx + 1)
-    ];
-    this._emitQueueChange();
-    return true;
-  }
-  removeQueueItem(itemId) {
-    const before = this._queue.length;
-    this._queue = this._queue.filter((q) => q.id !== itemId);
-    if (this._queue.length === before) return false;
-    this._emitQueueChange();
-    return true;
-  }
-  clearQueue() {
-    if (this._queue.length === 0) return;
-    this._clearQueue();
-  }
-  // ── Eventos ────────────────────────────────────────
-  on(event, handler) {
-    if (!this._listeners.has(event)) {
-      this._listeners.set(event, /* @__PURE__ */ new Set());
-    }
-    this._listeners.get(event).add(handler);
-    return () => {
-      var _a;
-      (_a = this._listeners.get(event)) == null ? void 0 : _a.delete(handler);
-    };
-  }
-  // ── Internals: routing de mensagens WS ─────────────
-  _handleMessage(msg) {
-    var _a, _b, _c, _d, _e, _f;
-    if (!(msg == null ? void 0 : msg.type)) return;
-    if (this._cancelled && msg.type !== "turn_started" && msg.type !== "error" && msg.type !== "task_update") {
-      return;
-    }
-    const payload = (_a = msg.payload) != null ? _a : {};
-    switch (msg.type) {
-      case "task_update": {
-        if (payload.action !== "created") return;
-        const task = payload.task;
-        if (!task) return;
-        if (!this._taskId) {
-          this._taskId = task.id;
-          this._task = task;
-          this._transport.register(task.id, this);
-          if (this._wsUnsubscribePending) {
-            this._wsUnsubscribePending();
-            this._wsUnsubscribePending = null;
-          }
-          this._wsUnsubscribe = this._transport.subscribe(
-            task.id,
-            (m) => this._handleMessage(m)
-          );
-          this._emit("taskCreated", { task });
-        } else if (this._taskId === task.id) {
-          this._task = task;
-        }
-        break;
-      }
-      case "turn_started": {
-        if (this._cancelled) {
-          this._cancelled = false;
-          this._awaitingTurnStarted = false;
-          if (this._turnStartedTimer) {
-            clearTimeout(this._turnStartedTimer);
-            this._turnStartedTimer = null;
-          }
-          if (this._pendingCancelResolve) {
-            this._pendingCancelResolve();
-            this._pendingCancelResolve = null;
-          }
-        }
-        if (this._status !== "streaming") {
-          this._setStatus("streaming");
-          this._content = "";
-        }
-        this._emit("turnStart", void 0);
-        break;
-      }
-      case "stream_delta": {
-        const kind = payload.subtype === "thinking" ? "tool" : "text";
-        const delta = String((_b = payload.delta) != null ? _b : "");
-        if (kind === "text") this._content += delta;
-        this._emit("delta", { delta, kind });
-        break;
-      }
-      case "stream_tool_activity": {
-        this._emit("tool", {
-          tool: String((_c = payload.tool) != null ? _c : ""),
-          input: payload.input,
-          content: payload.content,
-          timestamp: Number((_d = msg.timestamp) != null ? _d : Date.now())
-        });
-        break;
-      }
-      case "stream_end": {
-        const finalContent = this._content;
-        this._emit("turnEnd", { content: finalContent });
-        this._setStatus("idle");
-        this._shiftQueueAndSend();
-        break;
-      }
-      case "error": {
-        const error = String((_f = (_e = payload.error) != null ? _e : msg.error) != null ? _f : "Erro desconhecido");
-        this._emitError(error);
-        break;
-      }
-    }
-  }
-  // ── Fila interna ───────────────────────────────────
-  _enqueue(text, agentType) {
-    if (this._queue.length >= QUEUE_MAX) return;
-    const trimmed = text.trim();
-    if (this._queue.some((q) => q.text.trim() === trimmed)) return;
-    const item = {
-      id: `q-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
-      text,
-      agentType,
-      seq: this._transport.nextSeq(),
-      createdAt: Date.now(),
-      status: "pending"
-    };
-    this._queue = [...this._queue, item];
-    this._emitQueueChange();
-  }
-  _shiftQueueAndSend() {
-    if (this._queue.length === 0) return;
-    const [next, ...rest] = this._queue;
-    this._queue = rest;
-    this._emitQueueChange();
-    this.send(next.text, { agentType: next.agentType });
-  }
-  _clearQueue() {
-    if (this._queue.length === 0) return;
-    this._queue = [];
-    this._emitQueueChange();
-  }
-  // ── Helpers de emissão ─────────────────────────────
-  _emit(event, payload) {
-    const set = this._listeners.get(event);
-    if (!set) return;
-    for (const handler of set) {
-      try {
-        handler(payload);
-      } catch (err) {
-        console.error(`[AgentTaskSession] handler de '${event}' lan\xE7ou:`, err);
-      }
-    }
-  }
-  _emitError(error) {
-    this._emit("error", { error });
-    this._setStatus("error");
-  }
-  _emitQueueChange() {
-    this._emit("queueChange", { queue: this._queue });
-  }
-  _setStatus(next) {
-    if (this._status === next) return;
-    const previous = this._status;
-    this._status = next;
-    this._emit("statusChange", { status: next, previous });
-  }
-};
-
-// src/agent-chat.ts
-var ws = null;
-var connectPromise = null;
-var requestSeq = 0;
-var queueSeq = 0;
-var pendingRequests = /* @__PURE__ */ new Map();
-var sessionsByTaskId = /* @__PURE__ */ new Map();
-var handlersByTaskId = /* @__PURE__ */ new Map();
-var pendingHandlers = /* @__PURE__ */ new Map();
-var streamingTaskIds = /* @__PURE__ */ new Set();
-function nextRequestId() {
-  return `req-${Date.now()}-${++requestSeq}`;
-}
-function nextQueueSeq() {
-  return ++queueSeq;
-}
-function getRawToken() {
-  const config = getConfig();
-  if (!config.token) {
-    throw new Error("Agent Chat: token n\xE3o configurado. Fa\xE7a login primeiro ou passe token em configureSdkMitra.");
-  }
-  return stripBearer(config.token);
-}
-function resolveProjectId3(override) {
-  const config = getConfig();
-  const pid = override != null ? override : config.projectId;
-  if (pid == null) {
-    throw new Error("Agent Chat: projectId \xE9 obrigat\xF3rio. Passe nas options ou configure via configureSdkMitra({ projectId }).");
-  }
-  return pid;
-}
-function getWsUrl() {
-  var _a;
-  if (typeof window !== "undefined") {
-    const injected = (_a = window.__mitraEnv) == null ? void 0 : _a.agentWsUrl;
-    if (typeof injected === "string" && injected) return injected;
-  }
-  throw new Error("Agent Chat: window.__mitraEnv.agentWsUrl indispon\xEDvel. A SDK precisa rodar em uma app publicada pelo Mitra (build-proxy injeta __mitraEnv).");
-}
-function connect() {
-  if (ws && ws.readyState === WebSocket.OPEN) {
-    return Promise.resolve(ws);
-  }
-  if (connectPromise) return connectPromise;
-  const baseUrl = getWsUrl();
-  const token = getRawToken();
-  const separator = baseUrl.includes("?") ? "&" : "?";
-  const url = `${baseUrl}${separator}token=${encodeURIComponent(token)}`;
-  connectPromise = new Promise((resolve, reject) => {
-    const socket = new WebSocket(url);
-    let opened = false;
-    const timer = setTimeout(() => {
-      if (!opened) {
-        try {
-          socket.close();
-        } catch (e) {
-        }
-        connectPromise = null;
-        reject(new Error("Agent Chat: timeout ao conectar no WebSocket"));
-      }
-    }, 15e3);
-    socket.onopen = () => {
-      opened = true;
-      clearTimeout(timer);
-      ws = socket;
-      connectPromise = null;
-      resolve(socket);
-    };
-    socket.onerror = () => {
-      if (!opened) {
-        clearTimeout(timer);
-        connectPromise = null;
-        reject(new Error("Agent Chat: erro ao conectar no WebSocket"));
-      }
-    };
-    socket.onclose = () => {
-      if (ws === socket) ws = null;
-      for (const [id, pending] of pendingRequests) {
-        pending.reject(new Error("Agent Chat: conex\xE3o fechada"));
-        pendingRequests.delete(id);
-      }
-      streamingTaskIds.clear();
-    };
-    socket.onmessage = (event) => routeMessage(event.data);
-  });
-  return connectPromise;
-}
-function routeMessage(raw) {
-  var _a, _b;
-  let msg;
-  try {
-    msg = typeof raw === "string" ? JSON.parse(raw) : raw;
-  } catch (e) {
-    return;
-  }
-  if (!(msg == null ? void 0 : msg.type)) return;
-  if (msg.type === "response" && msg.requestId) {
-    const pending = pendingRequests.get(msg.requestId);
-    if (!pending) return;
-    pendingRequests.delete(msg.requestId);
-    if (msg.ok) pending.resolve(msg.data);
-    else pending.reject(new Error(msg.error || "Erro desconhecido"));
-    return;
-  }
-  if (msg.type === "streaming_state") {
-    streamingTaskIds.clear();
-    const ids = (_b = (_a = msg.payload) == null ? void 0 : _a.streamingTaskIds) != null ? _b : [];
-    for (const id of ids) streamingTaskIds.add(id);
-    return;
-  }
-  if (msg.type === "turn_started" && msg.taskId) {
-    streamingTaskIds.add(msg.taskId);
-  } else if (msg.type === "stream_end" && msg.taskId) {
-    streamingTaskIds.delete(msg.taskId);
-  }
-  if (msg.taskId) {
-    const set = handlersByTaskId.get(msg.taskId);
-    if (set) {
-      for (const handler of set) handler(msg);
-    }
-  }
-  if (msg.type === "task_update") {
-    for (const handler of pendingHandlers.values()) handler(msg);
-  }
-}
-var transport = {
-  async ensureConnected() {
-    await connect();
-  },
-  async request(type, payload) {
-    const socket = await connect();
-    const requestId = nextRequestId();
-    return new Promise((resolve, reject) => {
-      pendingRequests.set(requestId, {
-        resolve: (data) => resolve(data),
-        reject
-      });
-      try {
-        socket.send(JSON.stringify({ type, requestId, payload }));
-      } catch (err) {
-        pendingRequests.delete(requestId);
-        reject(err instanceof Error ? err : new Error(String(err)));
-      }
-    });
-  },
-  send(type, payload, taskId) {
-    connect().then((socket) => {
-      const requestId = nextRequestId();
-      socket.send(JSON.stringify({ type, requestId, payload, taskId }));
-    }).catch((err) => {
-      console.error("[agent-chat] send falhou:", err);
-    });
-  },
-  resolveProjectId(override) {
-    return resolveProjectId3(override);
-  },
-  nextSeq() {
-    return nextQueueSeq();
-  },
-  subscribe(taskId, handler) {
-    if (!handlersByTaskId.has(taskId)) {
-      handlersByTaskId.set(taskId, /* @__PURE__ */ new Set());
-    }
-    handlersByTaskId.get(taskId).add(handler);
-    return () => {
-      const set = handlersByTaskId.get(taskId);
-      if (!set) return;
-      set.delete(handler);
-      if (set.size === 0) handlersByTaskId.delete(taskId);
-    };
-  },
-  subscribePending(sessionId, handler) {
-    pendingHandlers.set(sessionId, handler);
-    return () => {
-      pendingHandlers.delete(sessionId);
-    };
-  },
-  isStreaming(taskId) {
-    return streamingTaskIds.has(taskId);
-  },
-  register(taskId, session) {
-    sessionsByTaskId.set(taskId, session);
-  },
-  unregister(taskId, _sessionId) {
-    if (taskId) sessionsByTaskId.delete(taskId);
-  }
-};
-function getTransport() {
-  return transport;
-}
-function manageAgentChatMitra(options) {
-  var _a;
-  if (isNewWorld()) throw new Error("manageAgentChatMitra ainda n\xE3o suportado no novo Mitra.");
-  if (options.action === "list") {
-    const projectId = resolveProjectId3(options.projectId);
-    return transport.request("chats", { action: "list", projectId });
-  }
-  if (options.action === "rename") {
-    if (!options.taskId) throw new Error("manageAgentChatMitra(rename): taskId obrigat\xF3rio.");
-    if (!((_a = options.name) == null ? void 0 : _a.trim())) throw new Error("manageAgentChatMitra(rename): name obrigat\xF3rio.");
-    return transport.request("chats", { action: "rename", taskId: options.taskId, name: options.name.trim() });
-  }
-  if (options.action === "delete") {
-    if (!options.taskId) throw new Error("manageAgentChatMitra(delete): taskId obrigat\xF3rio.");
-    return transport.request("chats", { action: "delete", taskId: options.taskId });
-  }
-  throw new Error(`manageAgentChatMitra: action inv\xE1lida (${options.action}).`);
-}
-function getAgentTaskMitra(options) {
-  if (isNewWorld()) throw new Error("getAgentTaskMitra ainda n\xE3o suportado no novo Mitra.");
-  if ("taskId" in options && options.taskId) {
-    const cached = sessionsByTaskId.get(options.taskId);
-    if (cached) return cached;
-    return new AgentTaskSession(
-      { kind: "existing", taskId: options.taskId },
-      transport
-    );
-  }
-  if ("create" in options && options.create) {
-    return new AgentTaskSession(
-      {
-        kind: "new",
-        projectId: options.projectId,
-        agentType: options.agentType,
-        modelId: options.modelId,
-        name: options.name
-      },
-      transport
-    );
-  }
-  throw new Error("getAgentTaskMitra: passe { create: true } ou { taskId }.");
-}
-
-// src/agent-credentials.ts
-var pendingVerifiers = /* @__PURE__ */ new Map();
-function manageAgentCredentialMitra(options) {
-  if (isNewWorld()) throw new Error("manageAgentCredentialMitra ainda n\xE3o suportado no novo Mitra.");
-  if (options.action === "auth") return authSubscription(options);
-  if (options.action === "connect") return connectSubscription(options);
-  return rpc(options);
-}
-function rpc(options) {
-  const transport2 = getTransport();
-  const { action, target, ...rest } = options;
-  const data = {};
-  for (const [k, v] of Object.entries(rest)) {
-    if (v !== void 0) data[k] = v;
-  }
-  return transport2.request("credentials", { action, target, data });
-}
-async function authSubscription(options) {
-  const { target } = options;
-  if (target === "claude") {
-    const start = await rpc({
-      action: "oauth_start",
-      target: "claude"
-    });
-    pendingVerifiers.set(start.state, start.codeVerifier);
-    return { target: "claude", authUrl: start.authUrl, state: start.state };
-  }
-  if (target === "codex") {
-    const start = await rpc({
-      action: "device_start",
-      target: "codex"
-    });
-    return {
-      target: "codex",
-      userCode: start.userCode,
-      verificationUrl: start.verificationUrl,
-      pollId: start.pollId
-    };
-  }
-  throw new Error(`manageAgentCredentialMitra(auth): target inv\xE1lido (${target}). Use 'claude' ou 'codex'.`);
-}
-function connectSubscription(options) {
-  const { target } = options;
-  if (target === "claude") return connectClaude(options);
-  if (target === "codex") return connectCodex(options);
-  throw new Error(`manageAgentCredentialMitra(connect): target inv\xE1lido (${target}). Use 'claude' ou 'codex'.`);
-}
-async function connectClaude(options) {
-  var _a;
-  const { code, state } = options;
-  if (!code || !state) {
-    throw new Error("manageAgentCredentialMitra(connect, claude): code e state s\xE3o obrigat\xF3rios (state vem de auth).");
-  }
-  const codeVerifier = pendingVerifiers.get(state);
-  const exchange = await rpc({
-    action: "oauth_exchange",
-    target: "claude",
-    code,
-    state,
-    // Se a SDK ainda tem o verifier (mesmo runtime), envia; senão o backend
-    // resolve via state (pkceStore). Cobre os dois caminhos.
-    ...codeVerifier ? { codeVerifier } : {}
-  });
-  pendingVerifiers.delete(state);
-  return {
-    target: "claude",
-    success: exchange.success === true,
-    expiresAt: exchange.expiresAt,
-    account: (_a = exchange.account) != null ? _a : null
-  };
-}
-async function connectCodex(options) {
-  var _a, _b;
-  const { pollId } = options;
-  if (!pollId) {
-    throw new Error("manageAgentCredentialMitra(connect, codex): pollId \xE9 obrigat\xF3rio (vem de auth).");
-  }
-  const pollInterval = (_a = options.pollIntervalMs) != null ? _a : 2e3;
-  const deadline = Date.now() + ((_b = options.deviceTimeoutMs) != null ? _b : 15 * 6e4);
-  while (Date.now() < deadline) {
-    const result = await rpc({ action: "device_poll", target: "codex", pollId });
-    if (result.status === "completed") {
-      return { target: "codex", success: true };
-    }
-    if (result.status === "failed" || result.status === "expired" || result.status === "not_found") {
-      throw new Error(`manageAgentCredentialMitra(connect, codex): ${result.status}${result.error ? ` \u2014 ${result.error}` : ""}`);
-    }
-    await sleep(pollInterval);
-  }
-  await rpc({ action: "device_cancel", target: "codex", pollId }).catch(() => {
-  });
-  throw new Error("manageAgentCredentialMitra(connect, codex): timeout.");
-}
-function sleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-
-// src/instance.ts
-function formatToken2(token) {
-  return `Bearer ${stripBearer(token)}`;
-}
-function getFetch4() {
-  if (typeof globalThis.fetch === "function") return globalThis.fetch;
-  throw new Error("fetch n\xE3o dispon\xEDvel. Use Node.js 18+ ou instale node-fetch.");
-}
-function buildQuery(params) {
-  return Object.entries(params).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&");
-}
-function createMitraInstance(initialConfig) {
-  var _a;
-  let _config = {
-    baseURL: ((_a = initialConfig.baseURL) == null ? void 0 : _a.replace(/\/+$/, "")) || "",
-    token: initialConfig.token ? stripBearer(initialConfig.token) : "",
-    refreshToken: initialConfig.refreshToken,
-    integrationURL: initialConfig.integrationURL,
-    authUrl: initialConfig.authUrl,
-    projectId: initialConfig.projectId
-  };
-  function resolveProjectId4(projectId) {
-    if (projectId != null) return projectId;
-    if (_config.projectId != null) return _config.projectId;
-    throw new Error("projectId \xE9 obrigat\xF3rio. Passe nas options ou configure via configureSdkMitra({ projectId }).");
-  }
-  function authHeaders() {
-    const headers = { "Content-Type": "application/json" };
-    if (_config.token) headers["Authorization"] = formatToken2(_config.token);
-    return headers;
-  }
-  async function handleResponse2(response) {
-    const text = await response.text();
-    const data = text ? JSON.parse(text) : null;
-    if (!response.ok) {
-      const base = (data == null ? void 0 : data.message) || (data == null ? void 0 : data.error) || `HTTP ${response.status}`;
-      const msg = (data == null ? void 0 : data.hint) ? `${base} \u2014 ${data.hint}` : base;
-      throw { message: msg, status: response.status, details: data };
-    }
-    return data;
+    return data;
   }
   async function tryRefreshToken2() {
     var _a2, _b;
     if (!_config.token || _config.projectId == null || !_config.baseURL) return false;
     try {
       const baseURL = _config.baseURL.replace(/\/+$/, "");
-      const resp = await getFetch4()(`${baseURL}/mitraspace/project/refreshedToken/${_config.projectId}`, {
+      const resp = await getFetch2()(`${baseURL}/mitraspace/project/refreshedToken/${_config.projectId}`, {
         method: "GET",
-        headers: { "Authorization": formatToken2(_config.token) }
+        headers: { "Authorization": formatToken(_config.token) }
       });
       if (resp.ok) {
         const data = await resp.json();
@@ -2072,7 +582,7 @@ function createMitraInstance(initialConfig) {
     }
   }
   async function fetchWithRefresh2(url, init) {
-    const fetchFn = getFetch4();
+    const fetchFn = getFetch2();
     const response = await fetchFn(url, init);
     if (response.status === 403) {
       const refreshed = await tryRefreshToken2();
@@ -2102,16 +612,6 @@ function createMitraInstance(initialConfig) {
       body: (opts == null ? void 0 : opts.body) !== void 0 ? JSON.stringify(opts.body) : void 0
     });
   }
-  async function requestUpload(endpoint, formData) {
-    const url = `${_config.baseURL}${endpoint}`;
-    const headers = {};
-    if (_config.token) headers["Authorization"] = formatToken2(_config.token);
-    return fetchWithRefresh2(url, {
-      method: "POST",
-      headers,
-      body: formData
-    });
-  }
   async function requestTenant(method, endpoint, tenantId, opts) {
     let url = `${_config.baseURL}${endpoint}`;
     if (opts == null ? void 0 : opts.params) {
@@ -2133,51 +633,20 @@ function createMitraInstance(initialConfig) {
       _config = { ..._config, token };
     },
     // Services
-    async executeDataLoader(options) {
-      const body = { projectId: resolveProjectId4(options.projectId), dataLoaderId: options.dataLoaderId };
-      if (options.input !== void 0) body.input = options.input;
-      return request("POST", "/interactions/executeDataLoader", { body });
-    },
-    async executeDbAction(options) {
-      const body = { projectId: resolveProjectId4(options.projectId), dbActionId: options.dbActionId };
-      if (options.input !== void 0) body.input = options.input;
-      return request("POST", "/interactions/executeDbAction", { body });
-    },
-    async setFileStatus(options) {
-      return request("POST", "/interactions/setFileStatus", {
-        body: { projectId: resolveProjectId4(options.projectId), fileName: options.fileName, targetPath: options.targetPath }
-      });
-    },
-    async setVariable(options) {
-      const body = { projectId: resolveProjectId4(options.projectId), key: options.key };
-      if (options.value !== void 0) body.value = options.value;
-      return request("POST", "/interactions/setVariable", { body });
-    },
-    async listVariables(options = {}) {
-      return request("GET", "/interactions/listVariables", { params: { projectId: resolveProjectId4(options.projectId) } });
-    },
-    async getVariable(options) {
-      return request("GET", "/interactions/getVariable", { params: { projectId: resolveProjectId4(options.projectId), key: options.key } });
-    },
-    async runAction(options) {
-      const body = { projectId: resolveProjectId4(options.projectId), actionId: options.actionId };
-      if (options.input !== void 0) body.input = options.input;
-      return request("POST", "/interactions/runAction", { body });
-    },
     async executeServerFunction(options) {
-      const body = { projectId: resolveProjectId4(options.projectId), serverFunctionId: options.serverFunctionId };
+      const body = { projectId: resolveProjectId2(options.projectId), serverFunctionId: options.serverFunctionId };
       if (options.input !== void 0) body.input = options.input;
       return request("POST", "/interactions/executeServerFunction", { body });
     },
     async executeServerFunctionAsync(options) {
-      const body = { projectId: resolveProjectId4(options.projectId), serverFunctionId: options.serverFunctionId };
+      const body = { projectId: resolveProjectId2(options.projectId), serverFunctionId: options.serverFunctionId };
       if (options.input !== void 0) body.input = options.input;
       return request("POST", "/interactions/executeServerFunctionAsync", { body });
     },
     async executePublicServerFunction(options) {
       const { projectId, serverFunctionId, input } = options;
       const url = `${_config.baseURL}/public/serverFunction/${projectId}/${serverFunctionId}/execute`;
-      const fetchFn = getFetch4();
+      const fetchFn = getFetch2();
       const response = await fetchFn(url, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
@@ -2188,7 +657,7 @@ function createMitraInstance(initialConfig) {
     async executePublicServerFunctionAsync(options) {
       const { projectId, serverFunctionId, input } = options;
       const url = `${_config.baseURL}/public/serverFunction/${projectId}/${serverFunctionId}/executeAsync`;
-      const fetchFn = getFetch4();
+      const fetchFn = getFetch2();
       const response = await fetchFn(url, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
@@ -2199,7 +668,7 @@ function createMitraInstance(initialConfig) {
     async getPublicServerFunctionExecution(options) {
       const { projectId, executionId } = options;
       const url = `${_config.baseURL}/public/serverFunction/${projectId}/execution/${executionId}`;
-      const fetchFn = getFetch4();
+      const fetchFn = getFetch2();
       const response = await fetchFn(url, {
         method: "GET",
         headers: { "Content-Type": "application/json" }
@@ -2208,32 +677,17 @@ function createMitraInstance(initialConfig) {
     },
     async stopServerFunctionExecution(options) {
       return request("POST", "/interactions/stopServerFunctionExecution", {
-        body: { projectId: resolveProjectId4(options.projectId), executionId: options.executionId }
+        body: { projectId: resolveProjectId2(options.projectId), executionId: options.executionId }
       });
     },
-    // Upload de Arquivos
-    async uploadFilePublic(options) {
-      const formData = new FormData();
-      formData.append("file", options.file);
-      formData.append("projectId", String(resolveProjectId4(options.projectId)));
-      if (options.debug !== void 0) formData.append("debug", String(options.debug));
-      return requestUpload("/interactions/uploadFilePublic", formData);
-    },
-    async uploadFileLoadable(options) {
-      const formData = new FormData();
-      formData.append("file", options.file);
-      formData.append("projectId", String(resolveProjectId4(options.projectId)));
-      if (options.debug !== void 0) formData.append("debug", String(options.debug));
-      return requestUpload("/interactions/uploadFileLoadable", formData);
-    },
     // Integrations
     async listIntegrations(options = {}) {
-      return request("GET", "/interactions/integrations", { params: { projectId: resolveProjectId4(options.projectId) } });
+      return request("GET", "/interactions/integrations", { params: { projectId: resolveProjectId2(options.projectId) } });
     },
     async callIntegration(options) {
       const body = {
         integrationSlug: options.connection,
-        projectId: resolveProjectId4(options.projectId),
+        projectId: resolveProjectId2(options.projectId),
         method: options.method
       };
       if (options.endpoint !== void 0) body.endpoint = options.endpoint;
@@ -2244,241 +698,473 @@ function createMitraInstance(initialConfig) {
     // Dynamic Schema CRUD
     async listRecords(options) {
       const { tableName, page, size, filters, jdbcConnectionConfigId } = options;
-      const pid = resolveProjectId4(options.projectId);
+      const pid = resolveProjectId2(options.projectId);
       return requestTenant("GET", `/interactions/records/${tableName}`, pid, { params: { page, size, jdbcConnectionConfigId, ...filters } });
     },
     async getRecord(options) {
       const { tableName, id, jdbcConnectionConfigId } = options;
-      const pid = resolveProjectId4(options.projectId);
+      const pid = resolveProjectId2(options.projectId);
       return requestTenant("GET", `/interactions/records/${tableName}/${id}`, pid, { params: { jdbcConnectionConfigId } });
     },
     async createRecord(options) {
       const { tableName, data, jdbcConnectionConfigId } = options;
-      const pid = resolveProjectId4(options.projectId);
+      const pid = resolveProjectId2(options.projectId);
       return requestTenant("POST", `/interactions/records/${tableName}`, pid, { body: data, params: { jdbcConnectionConfigId } });
     },
     async updateRecord(options) {
       const { tableName, id, data, jdbcConnectionConfigId } = options;
-      const pid = resolveProjectId4(options.projectId);
+      const pid = resolveProjectId2(options.projectId);
       return requestTenant("PUT", `/interactions/records/${tableName}/${id}`, pid, { body: data, params: { jdbcConnectionConfigId } });
     },
     async patchRecord(options) {
       const { tableName, id, data, jdbcConnectionConfigId } = options;
-      const pid = resolveProjectId4(options.projectId);
+      const pid = resolveProjectId2(options.projectId);
       return requestTenant("PATCH", `/interactions/records/${tableName}/${id}`, pid, { body: data, params: { jdbcConnectionConfigId } });
     },
     async deleteRecord(options) {
       const { tableName, id, jdbcConnectionConfigId } = options;
-      const pid = resolveProjectId4(options.projectId);
+      const pid = resolveProjectId2(options.projectId);
       return requestTenant("DELETE", `/interactions/records/${tableName}/${id}`, pid, { params: { jdbcConnectionConfigId } });
     },
     async createRecordsBatch(options) {
       const { tableName, records, jdbcConnectionConfigId } = options;
-      const pid = resolveProjectId4(options.projectId);
+      const pid = resolveProjectId2(options.projectId);
       return requestTenant("POST", `/interactions/records/${tableName}/batch`, pid, { body: records, params: { jdbcConnectionConfigId } });
-    },
-    // Profile Management
-    async listProfiles(options = {}) {
-      return request("GET", "/interactions/profiles", { params: { projectId: resolveProjectId4(options.projectId) } });
-    },
-    async getProfileDetails(options) {
-      return request("GET", `/interactions/profiles/${options.profileId}`, { params: { projectId: resolveProjectId4(options.projectId) } });
-    },
-    async createProfile(options) {
-      const body = { projectId: resolveProjectId4(options.projectId), name: options.name };
-      if (options.color !== void 0) body.color = options.color;
-      if (options.homeScreenId !== void 0) body.homeScreenId = options.homeScreenId;
-      return request("POST", "/interactions/profiles", { body });
-    },
-    async updateProfile(options) {
-      const body = { projectId: resolveProjectId4(options.projectId), profileId: options.profileId };
-      if (options.name !== void 0) body.name = options.name;
-      if (options.color !== void 0) body.color = options.color;
-      if (options.homeScreenId !== void 0) body.homeScreenId = options.homeScreenId;
-      return request("PUT", "/interactions/profiles", { body });
-    },
-    async deleteProfile(options) {
-      return request("DELETE", "/interactions/profiles", { body: { projectId: resolveProjectId4(options.projectId), profileId: options.profileId } });
-    },
-    async setProfileUsers(options) {
-      return request("POST", "/interactions/profiles/users", {
-        body: { projectId: resolveProjectId4(options.projectId), profileId: options.profileId, userIds: options.userIds }
-      });
-    },
-    async setProfileSelectTables(options) {
-      return request("POST", "/interactions/profiles/selectTables", {
-        body: { projectId: resolveProjectId4(options.projectId), profileId: options.profileId, tables: options.tables }
-      });
-    },
-    async setProfileDmlTables(options) {
-      return request("POST", "/interactions/profiles/dmlTables", {
-        body: { projectId: resolveProjectId4(options.projectId), profileId: options.profileId, tables: options.tables }
-      });
-    },
-    async setProfileActions(options) {
-      return request("POST", "/interactions/profiles/actions", {
-        body: { projectId: resolveProjectId4(options.projectId), profileId: options.profileId, actionIds: options.actionIds }
-      });
-    },
-    async setProfileScreens(options) {
-      return request("POST", "/interactions/profiles/screens", {
-        body: { projectId: resolveProjectId4(options.projectId), profileId: options.profileId, screenIds: options.screenIds }
-      });
-    },
-    async setProfileServerFunctions(options) {
-      return request("POST", "/interactions/profiles/serverFunctions", {
-        body: { projectId: resolveProjectId4(options.projectId), profileId: options.profileId, serverFunctionIds: options.serverFunctionIds }
+    }
+  };
+  return instance;
+}
+
+// src/config.ts
+var globalConfig = null;
+function stripBearer(token) {
+  let t = token.trim();
+  while (/^bearer\s+/i.test(t)) {
+    t = t.replace(/^bearer\s+/i, "").trim();
+  }
+  return t;
+}
+function parseBody(text) {
+  if (!text) return { data: null, isJson: true };
+  try {
+    return { data: JSON.parse(text), isJson: true };
+  } catch (e) {
+    return { data: text, isJson: false };
+  }
+}
+var SESSION_STORE_KEY = "mitra-session";
+function safeLocalStorage() {
+  try {
+    return typeof localStorage !== "undefined" ? localStorage : null;
+  } catch (e) {
+    return null;
+  }
+}
+function persistRefreshToken(refreshToken) {
+  const ls = safeLocalStorage();
+  if (!ls) return;
+  try {
+    const raw = ls.getItem(SESSION_STORE_KEY);
+    const obj = raw ? JSON.parse(raw) : {};
+    obj.refreshToken = refreshToken;
+    ls.setItem(SESSION_STORE_KEY, JSON.stringify(obj));
+  } catch (e) {
+  }
+}
+function readPersistedRefreshToken() {
+  const ls = safeLocalStorage();
+  if (!ls) return void 0;
+  try {
+    const raw = ls.getItem(SESSION_STORE_KEY);
+    if (!raw) return void 0;
+    const obj = JSON.parse(raw);
+    return typeof (obj == null ? void 0 : obj.refreshToken) === "string" && obj.refreshToken ? obj.refreshToken : void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+function readInjectedEnv() {
+  if (typeof window === "undefined") return {};
+  const env = window.__mitraEnv;
+  if (!env || typeof env !== "object") return {};
+  const out = {};
+  if (typeof env.apiBaseURL === "string" && env.apiBaseURL) out.baseURL = env.apiBaseURL;
+  if (typeof env.integrationURL === "string" && env.integrationURL) out.integrationURL = env.integrationURL;
+  if (typeof env.authUrl === "string" && env.authUrl) out.authUrl = env.authUrl;
+  if (typeof env.authPageUrl === "string" && env.authPageUrl) out.authPageUrl = env.authPageUrl;
+  return out;
+}
+function configureSdkMitra(config = {}) {
+  const injected = readInjectedEnv();
+  const merged = { ...injected, ...config };
+  if (!merged.baseURL) {
+    throw new Error("baseURL \xE9 obrigat\xF3rio. Passe em configureSdkMitra({ baseURL }), fa\xE7a login para receber via sdk-auth, ou rode em uma app publicada pelo Mitra (window.__mitraEnv).");
+  }
+  if (merged.token != null) merged.token = stripBearer(merged.token);
+  if (!merged.refreshToken) {
+    const persisted = readPersistedRefreshToken();
+    if (persisted) merged.refreshToken = persisted;
+  } else {
+    persistRefreshToken(merged.refreshToken);
+  }
+  globalConfig = {
+    ...merged,
+    baseURL: merged.baseURL.replace(/\/+$/, "")
+  };
+  return createMitraInstance(globalConfig);
+}
+function getConfig() {
+  if (!globalConfig) {
+    throw new Error("SDK n\xE3o configurado. Chame configureSdkMitra() primeiro.");
+  }
+  return globalConfig;
+}
+function isConfigured() {
+  return globalConfig !== null;
+}
+function updateGlobalToken(token, refreshToken) {
+  if (globalConfig) {
+    globalConfig = {
+      ...globalConfig,
+      token: stripBearer(token),
+      ...refreshToken !== void 0 ? { refreshToken } : {}
+    };
+    if (refreshToken) persistRefreshToken(refreshToken);
+  }
+}
+function resolveProjectId(projectId) {
+  if (projectId != null) return projectId;
+  if ((globalConfig == null ? void 0 : globalConfig.projectId) != null) return globalConfig.projectId;
+  throw new Error("projectId \xE9 obrigat\xF3rio. Passe nas options ou configure via configureSdkMitra({ projectId }).");
+}
+
+// src/client.ts
+function getFetch3() {
+  if (typeof globalThis.fetch === "function") {
+    return globalThis.fetch;
+  }
+  throw new Error("fetch n\xE3o dispon\xEDvel. Use Node.js 18+ ou instale node-fetch.");
+}
+function formatToken2(token) {
+  return `Bearer ${stripBearer(token)}`;
+}
+function buildHeaders() {
+  const config = getConfig();
+  const headers = { "Content-Type": "application/json" };
+  if (config.token) headers["Authorization"] = formatToken2(config.token);
+  return headers;
+}
+function buildUrl(endpoint, params) {
+  const config = getConfig();
+  let url = `${config.baseURL}${endpoint}`;
+  if (params) {
+    const query = Object.entries(params).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&");
+    if (query) url += `?${query}`;
+  }
+  return url;
+}
+async function tryRefreshToken() {
+  var _a, _b;
+  const config = getConfig();
+  if (!config.token || config.projectId == null || !config.baseURL) return false;
+  if (!isNewWorld()) {
+    try {
+      const baseURL = config.baseURL.replace(/\/+$/, "");
+      const resp = await getFetch3()(`${baseURL}/mitraspace/project/refreshedToken/${config.projectId}`, {
+        method: "GET",
+        headers: { "Authorization": formatToken2(config.token) }
       });
-    },
-    // Password Reset (pré-login)
-    sendPasswordResetCode(options) {
-      var _a2;
-      return sendPasswordResetCodeMitra({ ...options, authUrl: (_a2 = options.authUrl) != null ? _a2 : _config.authUrl });
-    },
-    validatePasswordResetCode(options) {
-      var _a2;
-      return validatePasswordResetCodeMitra({ ...options, authUrl: (_a2 = options.authUrl) != null ? _a2 : _config.authUrl });
-    },
-    resetPassword(options) {
-      var _a2;
-      return resetPasswordMitra({ ...options, authUrl: (_a2 = options.authUrl) != null ? _a2 : _config.authUrl });
-    },
-    // Agent Chat (embedded)
-    getAgentTask(options) {
-      return getAgentTaskMitra(options);
-    },
-    manageAgentChat(options) {
-      return manageAgentChatMitra(options);
-    },
-    manageAgentCredential(options) {
-      return manageAgentCredentialMitra(options);
-    },
-    // Chat
-    openChat() {
-      openChatMitra();
-    },
-    closeChat() {
-      closeChatMitra();
+      if (resp.ok) {
+        const data = await resp.json();
+        if (data.token) {
+          const newToken = `Bearer ${stripBearer(data.token)}`;
+          const session = {
+            token: newToken,
+            baseURL: ((_a = data.merge) == null ? void 0 : _a.backURL) || config.baseURL,
+            ...((_b = data.merge) == null ? void 0 : _b.integrationURL) ? { integrationURL: data.merge.integrationURL } : {}
+          };
+          updateGlobalToken(session.token);
+          if (config.onTokenRefresh) config.onTokenRefresh(session);
+          return true;
+        }
+      }
+    } catch (e) {
+    }
+  }
+  if (!config.authUrl || typeof window === "undefined") return false;
+  try {
+    const session = await refreshTokenSilently3(config.authUrl, config.projectId);
+    updateGlobalToken(session.token, session.refreshToken);
+    if (config.onTokenRefresh) config.onTokenRefresh(session);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+async function handleResponse(response) {
+  const text = await response.text();
+  const { data, isJson } = parseBody(text);
+  if (!response.ok) {
+    const fallback = !isJson && text ? `HTTP ${response.status} \u2014 ${text}` : `HTTP ${response.status}`;
+    const base = isJson && ((data == null ? void 0 : data.message) || (data == null ? void 0 : data.error)) || fallback;
+    const msg = isJson && (data == null ? void 0 : data.hint) ? `${base} \u2014 ${data.hint}` : base;
+    throw {
+      message: msg,
+      status: response.status,
+      details: data
+    };
+  }
+  return data;
+}
+async function fetchWithRefresh(url, init) {
+  const fetchFn = getFetch3();
+  const response = await fetchFn(url, init);
+  const expiredStatus = isNewWorld() ? 401 : 403;
+  if (response.status === expiredStatus) {
+    const refreshed = await tryRefreshToken();
+    if (refreshed) {
+      const newHeaders = { ...buildHeaders() };
+      const oldHeaders = init.headers;
+      if (oldHeaders) {
+        for (const [k, v] of Object.entries(oldHeaders)) {
+          if (k !== "Authorization") newHeaders[k] = v;
+        }
+      }
+      const retryResponse = await fetchFn(url, { ...init, headers: newHeaders });
+      return handleResponse(retryResponse);
     }
+  }
+  return handleResponse(response);
+}
+var http = {
+  async get(endpoint, params) {
+    return fetchWithRefresh(buildUrl(endpoint, params), {
+      method: "GET",
+      headers: buildHeaders()
+    });
+  },
+  async post(endpoint, body) {
+    return fetchWithRefresh(buildUrl(endpoint), {
+      method: "POST",
+      headers: buildHeaders(),
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  },
+  async put(endpoint, body) {
+    return fetchWithRefresh(buildUrl(endpoint), {
+      method: "PUT",
+      headers: buildHeaders(),
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  },
+  async del(endpoint, params) {
+    return fetchWithRefresh(buildUrl(endpoint, params), {
+      method: "DELETE",
+      headers: buildHeaders()
+    });
+  },
+  async delBody(endpoint, body) {
+    return fetchWithRefresh(buildUrl(endpoint), {
+      method: "DELETE",
+      headers: buildHeaders(),
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  },
+  async upload(endpoint, formData) {
+    const config = getConfig();
+    const headers = {};
+    if (config.token) headers["Authorization"] = formatToken2(config.token);
+    return fetchWithRefresh(buildUrl(endpoint), {
+      method: "POST",
+      headers,
+      body: formData
+    });
+  }
+};
+async function requestWithTenant(method, endpoint, tenantId, options) {
+  const headers = {
+    ...buildHeaders(),
+    "X-TenantID": String(tenantId)
   };
-  return instance;
+  return fetchWithRefresh(buildUrl(endpoint, options == null ? void 0 : options.params), {
+    method,
+    headers,
+    body: (options == null ? void 0 : options.body) !== void 0 ? JSON.stringify(options.body) : void 0
+  });
 }
+var httpTenant = {
+  get(endpoint, tenantId, params) {
+    return requestWithTenant("GET", endpoint, tenantId, { params });
+  },
+  post(endpoint, tenantId, body, params) {
+    return requestWithTenant("POST", endpoint, tenantId, { body, params });
+  },
+  put(endpoint, tenantId, body, params) {
+    return requestWithTenant("PUT", endpoint, tenantId, { body, params });
+  },
+  patch(endpoint, tenantId, body, params) {
+    return requestWithTenant("PATCH", endpoint, tenantId, { body, params });
+  },
+  del(endpoint, tenantId, params) {
+    return requestWithTenant("DELETE", endpoint, tenantId, { params });
+  }
+};
 
-// src/config.ts
-var globalConfig = null;
-function stripBearer(token) {
-  let t = token.trim();
-  while (/^bearer\s+/i.test(t)) {
-    t = t.replace(/^bearer\s+/i, "").trim();
+// src/services.ts
+async function executeServerFunctionMitra(options) {
+  const body = {
+    projectId: resolveProjectId(options.projectId),
+    serverFunctionId: options.serverFunctionId
+  };
+  if (options.input !== void 0) {
+    body.input = options.input;
   }
-  return t;
+  return http.post("/interactions/executeServerFunction", body);
 }
-function readInjectedEnv() {
-  if (typeof window === "undefined") return {};
-  const env = window.__mitraEnv;
-  if (!env || typeof env !== "object") return {};
-  const out = {};
-  if (typeof env.apiBaseURL === "string" && env.apiBaseURL) out.baseURL = env.apiBaseURL;
-  if (typeof env.integrationURL === "string" && env.integrationURL) out.integrationURL = env.integrationURL;
-  if (typeof env.authUrl === "string" && env.authUrl) out.authUrl = env.authUrl;
-  return out;
+async function executeServerFunctionAsyncMitra(options) {
+  const body = {
+    projectId: resolveProjectId(options.projectId),
+    serverFunctionId: options.serverFunctionId
+  };
+  if (options.input !== void 0) {
+    body.input = options.input;
+  }
+  return http.post("/interactions/executeServerFunctionAsync", body);
 }
-function configureSdkMitra(config = {}) {
-  const injected = readInjectedEnv();
-  const merged = { ...injected, ...config };
-  if (!merged.baseURL) {
-    throw new Error("baseURL \xE9 obrigat\xF3rio. Passe em configureSdkMitra({ baseURL }), fa\xE7a login para receber via sdk-auth, ou rode em uma app publicada pelo Mitra (window.__mitraEnv).");
+async function executePublicServerFunctionMitra(options) {
+  const { projectId, serverFunctionId, input } = options;
+  const baseURL = getConfig().baseURL;
+  const url = `${baseURL}/public/serverFunction/${projectId}/${serverFunctionId}/execute`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(input || {})
+  });
+  if (!response.ok) {
+    const data = await response.json().catch(() => null);
+    const msg = (data == null ? void 0 : data.message) || (data == null ? void 0 : data.error) || `HTTP ${response.status}`;
+    throw { message: msg, status: response.status, details: data };
   }
-  if (merged.token != null) merged.token = stripBearer(merged.token);
-  globalConfig = {
-    ...merged,
-    baseURL: merged.baseURL.replace(/\/+$/, "")
-  };
-  if (merged.token && typeof window !== "undefined") {
-    const chat = window.__mitraChat;
-    if (chat) chat.init(merged.token);
+  return response.json();
+}
+async function executePublicServerFunctionAsyncMitra(options) {
+  const { projectId, serverFunctionId, input } = options;
+  const baseURL = getConfig().baseURL;
+  const url = `${baseURL}/public/serverFunction/${projectId}/${serverFunctionId}/executeAsync`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(input || {})
+  });
+  if (!response.ok) {
+    const data = await response.json().catch(() => null);
+    const msg = (data == null ? void 0 : data.message) || (data == null ? void 0 : data.error) || `HTTP ${response.status}`;
+    throw { message: msg, status: response.status, details: data };
   }
-  return createMitraInstance(globalConfig);
+  return response.json();
 }
-function getConfig() {
-  if (!globalConfig) {
-    throw new Error("SDK n\xE3o configurado. Chame configureSdkMitra() primeiro.");
+async function getPublicServerFunctionExecutionMitra(options) {
+  const { projectId, executionId } = options;
+  const baseURL = getConfig().baseURL;
+  const url = `${baseURL}/public/serverFunction/${projectId}/execution/${executionId}`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: { "Content-Type": "application/json" }
+  });
+  if (!response.ok) {
+    const data = await response.json().catch(() => null);
+    const msg = (data == null ? void 0 : data.message) || (data == null ? void 0 : data.error) || `HTTP ${response.status}`;
+    throw { message: msg, status: response.status, details: data };
   }
-  return globalConfig;
+  return response.json();
 }
-function isConfigured() {
-  return globalConfig !== null;
+async function listIntegrationsMitra(options = {}) {
+  return http.get("/interactions/integrations", {
+    projectId: resolveProjectId(options.projectId)
+  });
 }
-function updateGlobalToken(token, refreshToken) {
-  if (globalConfig) {
-    globalConfig = {
-      ...globalConfig,
-      token: stripBearer(token),
-      ...refreshToken !== void 0 ? { refreshToken } : {}
-    };
+async function callIntegrationMitra(options) {
+  const body = {
+    integrationSlug: options.connection,
+    projectId: resolveProjectId(options.projectId),
+    method: options.method
+  };
+  if (options.endpoint !== void 0) {
+    body.endpoint = options.endpoint;
+  }
+  if (options.params !== void 0) {
+    body.params = options.params;
+  }
+  if (options.body !== void 0) {
+    body.body = options.body;
   }
+  return http.post("/interactions/integrations/call", body);
 }
-function resolveProjectId2(projectId) {
-  if (projectId != null) return projectId;
-  if ((globalConfig == null ? void 0 : globalConfig.projectId) != null) return globalConfig.projectId;
-  throw new Error("projectId \xE9 obrigat\xF3rio. Passe nas options ou configure via configureSdkMitra({ projectId }).");
+async function stopServerFunctionExecutionMitra(options) {
+  return http.post("/interactions/stopServerFunctionExecution", {
+    projectId: resolveProjectId(options.projectId),
+    executionId: options.executionId
+  });
+}
+async function listRecordsMitra(options) {
+  const { tableName, page, size, filters, jdbcConnectionConfigId } = options;
+  const pid = resolveProjectId(options.projectId);
+  return httpTenant.get(`/interactions/records/${tableName}`, pid, { page, size, jdbcConnectionConfigId, ...filters });
+}
+async function getRecordMitra(options) {
+  const { tableName, id, jdbcConnectionConfigId } = options;
+  const pid = resolveProjectId(options.projectId);
+  return httpTenant.get(`/interactions/records/${tableName}/${id}`, pid, { jdbcConnectionConfigId });
+}
+async function createRecordMitra(options) {
+  const { tableName, data, jdbcConnectionConfigId } = options;
+  const pid = resolveProjectId(options.projectId);
+  return httpTenant.post(`/interactions/records/${tableName}`, pid, data, { jdbcConnectionConfigId });
+}
+async function updateRecordMitra(options) {
+  const { tableName, id, data, jdbcConnectionConfigId } = options;
+  const pid = resolveProjectId(options.projectId);
+  return httpTenant.put(`/interactions/records/${tableName}/${id}`, pid, data, { jdbcConnectionConfigId });
+}
+async function patchRecordMitra(options) {
+  const { tableName, id, data, jdbcConnectionConfigId } = options;
+  const pid = resolveProjectId(options.projectId);
+  return httpTenant.patch(`/interactions/records/${tableName}/${id}`, pid, data, { jdbcConnectionConfigId });
+}
+async function deleteRecordMitra(options) {
+  const { tableName, id, jdbcConnectionConfigId } = options;
+  const pid = resolveProjectId(options.projectId);
+  return httpTenant.del(`/interactions/records/${tableName}/${id}`, pid, { jdbcConnectionConfigId });
+}
+async function createRecordsBatchMitra(options) {
+  const { tableName, records, jdbcConnectionConfigId } = options;
+  const pid = resolveProjectId(options.projectId);
+  return httpTenant.post(`/interactions/records/${tableName}/batch`, pid, records, { jdbcConnectionConfigId });
 }
 
 exports.callIntegrationMitra = callIntegrationMitra;
-exports.closeChatMitra = closeChatMitra;
 exports.configureSdkMitra = configureSdkMitra;
 exports.createMitraInstance = createMitraInstance;
-exports.createProfileMitra = createProfileMitra;
 exports.createRecordMitra = createRecordMitra;
 exports.createRecordsBatchMitra = createRecordsBatchMitra;
-exports.deleteProfileMitra = deleteProfileMitra;
 exports.deleteRecordMitra = deleteRecordMitra;
-exports.emailLoginMitra = emailLoginMitra3;
-exports.emailResendCodeMitra = emailResendCodeMitra3;
-exports.emailSignupMitra = emailSignupMitra3;
-exports.emailVerifyCodeMitra = emailVerifyCodeMitra3;
-exports.executeDataLoaderMitra = executeDataLoaderMitra;
-exports.executeDbActionMitra = executeDbActionMitra;
+exports.exchangeSsoCodeMitra = exchangeSsoCodeMitra2;
 exports.executePublicServerFunctionAsyncMitra = executePublicServerFunctionAsyncMitra;
 exports.executePublicServerFunctionMitra = executePublicServerFunctionMitra;
 exports.executeServerFunctionAsyncMitra = executeServerFunctionAsyncMitra;
 exports.executeServerFunctionMitra = executeServerFunctionMitra;
-exports.getAgentTaskMitra = getAgentTaskMitra;
 exports.getConfig = getConfig;
-exports.getProfileDetailsMitra = getProfileDetailsMitra;
 exports.getPublicServerFunctionExecutionMitra = getPublicServerFunctionExecutionMitra;
 exports.getRecordMitra = getRecordMitra;
-exports.getVariableMitra = getVariableMitra;
 exports.listIntegrationsMitra = listIntegrationsMitra;
-exports.listProfilesMitra = listProfilesMitra;
 exports.listRecordsMitra = listRecordsMitra;
-exports.listVariablesMitra = listVariablesMitra;
 exports.loginMitra = loginMitra3;
-exports.loginWithEmailMitra = loginWithEmailMitra3;
 exports.loginWithGoogleMitra = loginWithGoogleMitra3;
 exports.loginWithMicrosoftMitra = loginWithMicrosoftMitra3;
-exports.manageAgentChatMitra = manageAgentChatMitra;
-exports.manageAgentCredentialMitra = manageAgentCredentialMitra;
-exports.openChatMitra = openChatMitra;
 exports.patchRecordMitra = patchRecordMitra;
 exports.refreshTokenSilently = refreshTokenSilently3;
-exports.resetPasswordMitra = resetPasswordMitra;
-exports.resolveProjectId = resolveProjectId2;
-exports.runActionMitra = runActionMitra;
-exports.sendPasswordResetCodeMitra = sendPasswordResetCodeMitra;
-exports.setFileStatusMitra = setFileStatusMitra;
-exports.setProfileActionsMitra = setProfileActionsMitra;
-exports.setProfileDmlTablesMitra = setProfileDmlTablesMitra;
-exports.setProfileScreensMitra = setProfileScreensMitra;
-exports.setProfileSelectTablesMitra = setProfileSelectTablesMitra;
-exports.setProfileServerFunctionsMitra = setProfileServerFunctionsMitra;
-exports.setProfileUsersMitra = setProfileUsersMitra;
-exports.setVariableMitra = setVariableMitra;
+exports.resolveProjectId = resolveProjectId;
 exports.stopServerFunctionExecutionMitra = stopServerFunctionExecutionMitra;
-exports.updateProfileMitra = updateProfileMitra;
 exports.updateRecordMitra = updateRecordMitra;
-exports.uploadFileLoadableMitra = uploadFileLoadableMitra;
-exports.uploadFilePublicMitra = uploadFilePublicMitra;
-exports.validatePasswordResetCodeMitra = validatePasswordResetCodeMitra;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map