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

package/dist/index.js

@@ -222,15 +222,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) {
@@ -407,7 +403,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);
@@ -500,6 +496,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)}`;
@@ -521,7 +1223,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 }).");
@@ -634,12 +1336,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 });
     },
@@ -677,17 +1379,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;
@@ -698,38 +1400,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;
@@ -832,7 +1544,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 }).");
@@ -1013,7 +1725,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) {
@@ -1023,7 +1735,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) {
@@ -1080,13 +1792,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) {
@@ -1102,43 +1814,43 @@ 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 });
 }
 
@@ -1153,6 +1865,7 @@ exports.executePublicServerFunctionAsyncMitra = executePublicServerFunctionAsync
 exports.executePublicServerFunctionMitra = executePublicServerFunctionMitra;
 exports.executeServerFunctionAsyncMitra = executeServerFunctionAsyncMitra;
 exports.executeServerFunctionMitra = executeServerFunctionMitra;
+exports.getAgentTaskMitra = getAgentTaskMitra;
 exports.getConfig = getConfig;
 exports.getPublicServerFunctionExecutionMitra = getPublicServerFunctionExecutionMitra;
 exports.getRecordMitra = getRecordMitra;
@@ -1161,9 +1874,11 @@ exports.listRecordsMitra = listRecordsMitra;
 exports.loginMitra = loginMitra3;
 exports.loginWithGoogleMitra = loginWithGoogleMitra3;
 exports.loginWithMicrosoftMitra = loginWithMicrosoftMitra3;
+exports.manageAgentChatMitra = manageAgentChatMitra;
+exports.manageAgentCredentialMitra = manageAgentCredentialMitra;
 exports.patchRecordMitra = patchRecordMitra;
 exports.refreshTokenSilently = refreshTokenSilently3;
-exports.resolveProjectId = resolveProjectId;
+exports.resolveProjectId = resolveProjectId2;
 exports.stopServerFunctionExecutionMitra = stopServerFunctionExecutionMitra;
 exports.updateRecordMitra = updateRecordMitra;
 //# sourceMappingURL=index.js.map