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

package/dist/index.mjs

@@ -220,15 +220,11 @@ 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://stg.mitralab.io/sdk-auth.html";
-async function fetchSsoAuthPageUrl(gatewayUrl) {
+var SSO_AUTH_PAGE_URL = "https://beta.infusion.cloud/sdk-auth.html";
+async function fetchSsoAuthPageUrl(_baseURL) {
   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;
-  }
+  return SSO_AUTH_PAGE_URL;
 }
 var SSO_ENABLED_PROVIDERS = ["google"];
 function providerLabel(provider) {
@@ -405,7 +401,7 @@ async function startSsoRedirect(provider, options) {
   const { authUrl, projectId } = resolveLoginOptions2(options);
   const state = generateState();
   const appId = String(projectId);
-  const authPageUrl = await fetchSsoAuthPageUrl(authUrl);
+  const authPageUrl = await fetchSsoAuthPageUrl();
   const redirectUri = stripToOriginPath(authPageUrl);
   persistRedirectContext({ state, provider, authUrl, projectId: appId, redirectUri });
   const startUrl = buildStartUrl(authPageUrl, provider, state, appId, authUrl, window.location.href);
@@ -498,6 +494,712 @@ async function exchangeSsoCodeMitra2(options) {
   return exchangeSsoCodeMitra(options);
 }
 
+// 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._agentId = init.agentId;
+      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;
+    if (this._status === "closed") {
+      throw new Error("AgentTaskSession: session fechada.");
+    }
+    if (!prompt.trim()) return;
+    const agentType = (_b = (_a = options == null ? void 0 : options.agentType) != null ? _a : this._agentType) != null ? _b : "claudecode";
+    const modelId = (_c = options == null ? void 0 : options.modelId) != null ? _c : this._modelId;
+    this._dispatchSend(prompt, agentType, modelId);
+  }
+  _dispatchSend(prompt, agentType, modelId) {
+    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 } : {},
+            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 (this._taskId) payload.taskId = this._taskId;
+    if (this._initialName && !this._taskId) {
+      payload.name = this._initialName;
+    }
+    if (this._agentId && !this._taskId) {
+      payload.agentId = this._agentId;
+    }
+    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 resolveProjectId(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() {
+  const config = getConfig();
+  if (!config.baseURL) {
+    throw new Error("Agent Chat: baseURL n\xE3o configurada. Configure via configureSdkMitra({ baseURL }).");
+  }
+  const base = config.baseURL.replace(/\/+$/, "");
+  return base.replace(/^http/, "ws") + "/sdk-ws";
+}
+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 resolveProjectId(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 (options.action === "list") {
+    const projectId = resolveProjectId(options.projectId);
+    const payload = { action: "list", projectId };
+    if (options.agentId) payload.agentId = options.agentId;
+    return transport.request("chats", payload);
+  }
+  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 ("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,
+        agentId: options.agentId
+      },
+      transport
+    );
+  }
+  throw new Error("getAgentTaskMitra: passe { create: true } ou { taskId }.");
+}
+
+// src/agent-credentials.ts
+var pendingVerifiers = /* @__PURE__ */ new Map();
+function manageAgentCredentialMitra(options) {
+  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 formatToken(token) {
   return `Bearer ${stripBearer(token)}`;
@@ -519,7 +1221,7 @@ function createMitraInstance(initialConfig) {
     authUrl: initialConfig.authUrl,
     projectId: initialConfig.projectId
   };
-  function resolveProjectId2(projectId) {
+  function resolveProjectId3(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 }).");
@@ -632,12 +1334,12 @@ function createMitraInstance(initialConfig) {
     },
     // Services
     async executeServerFunction(options) {
-      const body = { projectId: resolveProjectId2(options.projectId), serverFunctionId: options.serverFunctionId };
+      const body = { projectId: resolveProjectId3(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: resolveProjectId2(options.projectId), serverFunctionId: options.serverFunctionId };
+      const body = { projectId: resolveProjectId3(options.projectId), serverFunctionId: options.serverFunctionId };
       if (options.input !== void 0) body.input = options.input;
       return request("POST", "/interactions/executeServerFunctionAsync", { body });
     },
@@ -675,17 +1377,17 @@ function createMitraInstance(initialConfig) {
     },
     async stopServerFunctionExecution(options) {
       return request("POST", "/interactions/stopServerFunctionExecution", {
-        body: { projectId: resolveProjectId2(options.projectId), executionId: options.executionId }
+        body: { projectId: resolveProjectId3(options.projectId), executionId: options.executionId }
       });
     },
     // Integrations
     async listIntegrations(options = {}) {
-      return request("GET", "/interactions/integrations", { params: { projectId: resolveProjectId2(options.projectId) } });
+      return request("GET", "/interactions/integrations", { params: { projectId: resolveProjectId3(options.projectId) } });
     },
     async callIntegration(options) {
       const body = {
         integrationSlug: options.connection,
-        projectId: resolveProjectId2(options.projectId),
+        projectId: resolveProjectId3(options.projectId),
         method: options.method
       };
       if (options.endpoint !== void 0) body.endpoint = options.endpoint;
@@ -696,38 +1398,48 @@ function createMitraInstance(initialConfig) {
     // Dynamic Schema CRUD
     async listRecords(options) {
       const { tableName, page, size, filters, jdbcConnectionConfigId } = options;
-      const pid = resolveProjectId2(options.projectId);
+      const pid = resolveProjectId3(options.projectId);
       return requestTenant("GET", `/interactions/records/${tableName}`, pid, { params: { page, size, jdbcConnectionConfigId, ...filters } });
     },
     async getRecord(options) {
       const { tableName, id, jdbcConnectionConfigId } = options;
-      const pid = resolveProjectId2(options.projectId);
+      const pid = resolveProjectId3(options.projectId);
       return requestTenant("GET", `/interactions/records/${tableName}/${id}`, pid, { params: { jdbcConnectionConfigId } });
     },
     async createRecord(options) {
       const { tableName, data, jdbcConnectionConfigId } = options;
-      const pid = resolveProjectId2(options.projectId);
+      const pid = resolveProjectId3(options.projectId);
       return requestTenant("POST", `/interactions/records/${tableName}`, pid, { body: data, params: { jdbcConnectionConfigId } });
     },
     async updateRecord(options) {
       const { tableName, id, data, jdbcConnectionConfigId } = options;
-      const pid = resolveProjectId2(options.projectId);
+      const pid = resolveProjectId3(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 = resolveProjectId2(options.projectId);
+      const pid = resolveProjectId3(options.projectId);
       return requestTenant("PATCH", `/interactions/records/${tableName}/${id}`, pid, { body: data, params: { jdbcConnectionConfigId } });
     },
     async deleteRecord(options) {
       const { tableName, id, jdbcConnectionConfigId } = options;
-      const pid = resolveProjectId2(options.projectId);
+      const pid = resolveProjectId3(options.projectId);
       return requestTenant("DELETE", `/interactions/records/${tableName}/${id}`, pid, { params: { jdbcConnectionConfigId } });
     },
     async createRecordsBatch(options) {
       const { tableName, records, jdbcConnectionConfigId } = options;
-      const pid = resolveProjectId2(options.projectId);
+      const pid = resolveProjectId3(options.projectId);
       return requestTenant("POST", `/interactions/records/${tableName}/batch`, pid, { body: records, params: { jdbcConnectionConfigId } });
+    },
+    // Agent Chat (embedded)
+    getAgentTask(options) {
+      return getAgentTaskMitra(options);
+    },
+    manageAgentChat(options) {
+      return manageAgentChatMitra(options);
+    },
+    manageAgentCredential(options) {
+      return manageAgentCredentialMitra(options);
     }
   };
   return instance;
@@ -830,7 +1542,7 @@ function updateGlobalToken(token, refreshToken) {
     if (refreshToken) persistRefreshToken(refreshToken);
   }
 }
-function resolveProjectId(projectId) {
+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 }).");
@@ -1011,7 +1723,7 @@ var httpTenant = {
 // src/services.ts
 async function executeServerFunctionMitra(options) {
   const body = {
-    projectId: resolveProjectId(options.projectId),
+    projectId: resolveProjectId2(options.projectId),
     serverFunctionId: options.serverFunctionId
   };
   if (options.input !== void 0) {
@@ -1021,7 +1733,7 @@ async function executeServerFunctionMitra(options) {
 }
 async function executeServerFunctionAsyncMitra(options) {
   const body = {
-    projectId: resolveProjectId(options.projectId),
+    projectId: resolveProjectId2(options.projectId),
     serverFunctionId: options.serverFunctionId
   };
   if (options.input !== void 0) {
@@ -1078,13 +1790,13 @@ async function getPublicServerFunctionExecutionMitra(options) {
 }
 async function listIntegrationsMitra(options = {}) {
   return http.get("/interactions/integrations", {
-    projectId: resolveProjectId(options.projectId)
+    projectId: resolveProjectId2(options.projectId)
   });
 }
 async function callIntegrationMitra(options) {
   const body = {
     integrationSlug: options.connection,
-    projectId: resolveProjectId(options.projectId),
+    projectId: resolveProjectId2(options.projectId),
     method: options.method
   };
   if (options.endpoint !== void 0) {
@@ -1100,46 +1812,46 @@ async function callIntegrationMitra(options) {
 }
 async function stopServerFunctionExecutionMitra(options) {
   return http.post("/interactions/stopServerFunctionExecution", {
-    projectId: resolveProjectId(options.projectId),
+    projectId: resolveProjectId2(options.projectId),
     executionId: options.executionId
   });
 }
 async function listRecordsMitra(options) {
   const { tableName, page, size, filters, jdbcConnectionConfigId } = options;
-  const pid = resolveProjectId(options.projectId);
+  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 = resolveProjectId(options.projectId);
+  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 = resolveProjectId(options.projectId);
+  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 = resolveProjectId(options.projectId);
+  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 = resolveProjectId(options.projectId);
+  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 = resolveProjectId(options.projectId);
+  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 = resolveProjectId(options.projectId);
+  const pid = resolveProjectId2(options.projectId);
   return httpTenant.post(`/interactions/records/${tableName}/batch`, pid, records, { jdbcConnectionConfigId });
 }
 
-export { callIntegrationMitra, configureSdkMitra, createMitraInstance, createRecordMitra, createRecordsBatchMitra, deleteRecordMitra, exchangeSsoCodeMitra2 as exchangeSsoCodeMitra, executePublicServerFunctionAsyncMitra, executePublicServerFunctionMitra, executeServerFunctionAsyncMitra, executeServerFunctionMitra, getConfig, getPublicServerFunctionExecutionMitra, getRecordMitra, listIntegrationsMitra, listRecordsMitra, loginMitra3 as loginMitra, loginWithGoogleMitra3 as loginWithGoogleMitra, loginWithMicrosoftMitra3 as loginWithMicrosoftMitra, patchRecordMitra, refreshTokenSilently3 as refreshTokenSilently, resolveProjectId, stopServerFunctionExecutionMitra, updateRecordMitra };
+export { callIntegrationMitra, configureSdkMitra, createMitraInstance, createRecordMitra, createRecordsBatchMitra, deleteRecordMitra, exchangeSsoCodeMitra2 as exchangeSsoCodeMitra, executePublicServerFunctionAsyncMitra, executePublicServerFunctionMitra, executeServerFunctionAsyncMitra, executeServerFunctionMitra, getAgentTaskMitra, getConfig, getPublicServerFunctionExecutionMitra, getRecordMitra, listIntegrationsMitra, listRecordsMitra, loginMitra3 as loginMitra, loginWithGoogleMitra3 as loginWithGoogleMitra, loginWithMicrosoftMitra3 as loginWithMicrosoftMitra, manageAgentChatMitra, manageAgentCredentialMitra, patchRecordMitra, refreshTokenSilently3 as refreshTokenSilently, resolveProjectId2 as resolveProjectId, stopServerFunctionExecutionMitra, updateRecordMitra };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map