@m8tes/sdk 0.1.0-alpha.1 → 0.1.0-alpha.2

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var crypto = require('crypto');
+var crypto$1 = require('crypto');
 
 // src/protocol/events.ts
 var PROTOCOL_VERSION = "m8tes.stream.v2";
@@ -1082,12 +1082,52 @@ async function errorFromResponse(res, opts = {}) {
   return new Cls(message, fields);
 }
 
+// src/protocol/seg.ts
+var UNADDRESSABLE = /* @__PURE__ */ new Set(["", ".", ".."]);
+var SEPARATOR = "/";
+function reject(value, reason) {
+  throw new ValidationError(
+    `${JSON.stringify(value)} cannot be used as a URL path segment: ${reason}. Percent-encoding does not help \u2014 the server decodes the path before routing it.`,
+    { type: "invalid_request_error", code: 0, status: 0 }
+  );
+}
+function seg(value) {
+  if (value === null || value === void 0) {
+    reject(String(value), "an id of null or undefined is a caller bug, not a resource name");
+  }
+  const text = String(value);
+  if (UNADDRESSABLE.has(text)) {
+    reject(text, "it addresses the parent or the collection, not a resource");
+  }
+  if (text.includes(SEPARATOR)) {
+    reject(text, "a '/' becomes a real path separator once the server decodes it");
+  }
+  return encodeURIComponent(text);
+}
+
 // src/http.ts
 var DEFAULT_BASE_URL = "https://api.m8tes.ai/api/v2";
 var MAX_ATTEMPTS = 3;
 var INITIAL_BACKOFF_MS = 500;
 var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
 var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "PUT", "DELETE", "OPTIONS"]);
+var IDEMPOTENCY_HEADER = "idempotency-key";
+var REPLAY_HEADER = "idempotent-replay";
+var IDEMPOTENT_POST_PATHS = [
+  /^\/runs\/?$/,
+  /^\/runs\/with-files\/?$/,
+  /^\/runs\/\d+\/reply\/?$/,
+  /^\/runs\/\d+\/reply\/with-files\/?$/,
+  /^\/tasks\/\d+\/runs\/?$/
+];
+function isIdempotentRoute(path) {
+  const clean = path.split("?")[0] ?? "";
+  return IDEMPOTENT_POST_PATHS.some((re) => re.test(clean));
+}
+function isRetryable(method, path, headers) {
+  if (IDEMPOTENT_METHODS.has(method.toUpperCase())) return true;
+  return IDEMPOTENCY_HEADER in headers && isIdempotentRoute(path);
+}
 function backoff(ms, signal) {
   if (signal?.aborted) return Promise.resolve();
   return new Promise((resolve) => {
@@ -1148,14 +1188,22 @@ function createHttp(options = {}) {
     const message = diagnose(res, text, body, url) ?? (body ? parsed.message : text || parsed.message);
     return new (errorClassForStatus(res.status, errOpts))(message, parsed.fields);
   }
+  function mergeHeaders(...sources) {
+    const out = {};
+    for (const src of sources) {
+      for (const [k, v] of Object.entries(src ?? {})) out[k.toLowerCase()] = v;
+    }
+    return out;
+  }
   async function attempt(method, url, opts) {
-    const headers = {
-      authorization: `Bearer ${apiKey}`,
-      ...options.headers,
-      ...opts.headers
-    };
+    const headers = mergeHeaders(options.headers, opts.headers, {
+      authorization: `Bearer ${apiKey}`
+    });
     const init = { method, headers };
-    if (opts.body !== void 0) {
+    if (opts.form !== void 0) {
+      delete headers["content-type"];
+      init.body = opts.form;
+    } else if (opts.body !== void 0) {
       headers["content-type"] = "application/json";
       init.body = JSON.stringify(opts.body);
     }
@@ -1165,7 +1213,7 @@ function createHttp(options = {}) {
   }
   async function send(method, path, opts, errOpts = {}) {
     const url = `${baseUrl}${path}${opts.query ?? ""}`;
-    const idempotent = IDEMPOTENT_METHODS.has(method.toUpperCase());
+    const idempotent = isRetryable(method, path, mergeHeaders(options.headers, opts.headers));
     let lastNetworkError;
     for (let i = 0; i < MAX_ATTEMPTS; i++) {
       const isLast = i === MAX_ATTEMPTS - 1;
@@ -1213,6 +1261,11 @@ function createHttp(options = {}) {
     },
     async *stream(method, path, opts = {}) {
       const res = await send(method, path, opts, { conflictIsNotStreaming: true });
+      if (opts.onReplay && res.headers.get(REPLAY_HEADER)) {
+        const run = await res.json();
+        yield* opts.onReplay(run);
+        return;
+      }
       if (!res.body) return;
       const normalizer = opts.normalizer ?? createNormalizer();
       const decoder = createSseDecoder({ onMalformed: options.onMalformed });
@@ -1326,68 +1379,537 @@ function createAgentsResource(http) {
       return fetchPage({ ...params });
     },
     get(agentId, params = {}) {
-      return http.request("GET", `/agents/${agentId}`, { query: toQuery(params) });
+      return http.request("GET", `/agents/${seg(agentId)}`, { query: toQuery(params) });
     },
     update(agentId, params) {
       const { user_id, ...patch } = params;
-      return http.request("PATCH", `/agents/${agentId}`, {
+      return http.request("PATCH", `/agents/${seg(agentId)}`, {
         body: toBody(patch),
         query: toQuery({ user_id })
       });
     },
     async delete(agentId, params = {}) {
-      await http.request("DELETE", `/agents/${agentId}`, { query: toQuery(params) });
+      await http.request("DELETE", `/agents/${seg(agentId)}`, { query: toQuery(params) });
     },
-    enableWebhook(agentId) {
-      return http.request("POST", `/agents/${agentId}/webhook`, { body: {} });
+    enableWebhook(agentId, params = {}) {
+      return http.request("POST", `/agents/${seg(agentId)}/webhook`, {
+        body: {},
+        query: toQuery(params)
+      });
     },
-    async disableWebhook(agentId) {
-      await http.request("DELETE", `/agents/${agentId}/webhook`);
+    async disableWebhook(agentId, params = {}) {
+      await http.request("DELETE", `/agents/${seg(agentId)}/webhook`, { query: toQuery(params) });
     },
-    enableEmailInbox(agentId) {
-      return http.request("POST", `/agents/${agentId}/email-inbox`, { body: {} });
+    enableEmailInbox(agentId, params = {}) {
+      return http.request("POST", `/agents/${seg(agentId)}/email-inbox`, {
+        body: {},
+        query: toQuery(params)
+      });
     },
-    async disableEmailInbox(agentId) {
-      await http.request("DELETE", `/agents/${agentId}/email-inbox`);
+    async disableEmailInbox(agentId, params = {}) {
+      await http.request("DELETE", `/agents/${seg(agentId)}/email-inbox`, { query: toQuery(params) });
     }
   };
 }
 
 // src/resources/apps.ts
 function createAppsResource(http) {
-  const slug = (name) => encodeURIComponent(name);
+  const list = async (params = {}) => {
+    const res = await http.request("GET", "/apps/", {
+      query: toQuery({ user_id: params.user_id })
+    });
+    return new Page(res?.data ?? [], res?.has_more ?? false);
+  };
   return {
-    async list(params = {}) {
-      const res = await http.request("GET", "/apps/", {
-        query: toQuery({ user_id: params.user_id })
-      });
-      return new Page(res?.data ?? [], res?.has_more ?? false);
-    },
+    list,
     async isConnected(appName, params = {}) {
-      const { data } = await this.list(params);
+      const { data } = await list(params);
       return data.find((a) => a.name === appName)?.connected ?? false;
     },
     connectOauth(appName, params) {
-      return http.request("POST", `/apps/${slug(appName)}/connect`, {
+      return http.request("POST", `/apps/${seg(appName)}/connect`, {
         body: toBody({ ...params })
       });
     },
     connectApiKey(appName, params) {
-      return http.request("POST", `/apps/${slug(appName)}/connect/api-key`, {
+      return http.request("POST", `/apps/${seg(appName)}/connect/api-key`, {
         body: toBody({ ...params })
       });
     },
     connectComplete(appName, params) {
-      return http.request("POST", `/apps/${slug(appName)}/connect/complete`, {
+      return http.request("POST", `/apps/${seg(appName)}/connect/complete`, {
         body: toBody({ ...params })
       });
     },
     async disconnect(appName, params = {}) {
-      await http.request("DELETE", `/apps/${slug(appName)}/connections`, { query: toQuery(params) });
+      await http.request("DELETE", `/apps/${seg(appName)}/connections`, { query: toQuery(params) });
+    }
+  };
+}
+
+// src/resources/account.ts
+function createAccountResource(http) {
+  return {
+    export() {
+      return http.request("GET", "/account/export");
+    },
+    delete() {
+      return http.request("DELETE", "/account");
+    }
+  };
+}
+
+// src/resources/users.ts
+function pager(http, path) {
+  const fetchPage = async (p) => {
+    const res = await http.request("GET", path, {
+      query: toQuery(p)
+    });
+    return new Page(
+      res?.data ?? [],
+      res?.has_more ?? false,
+      (starting_after) => fetchPage({ ...p, starting_after })
+    );
+  };
+  return fetchPage;
+}
+function createUsersResource(http) {
+  return {
+    create(params) {
+      return http.request("POST", "/users/", { body: toBody({ ...params }) });
+    },
+    list(params = {}) {
+      return pager(http, "/users/")({ ...params });
+    },
+    get(userId) {
+      return http.request("GET", `/users/${seg(userId)}`);
+    },
+    update(userId, params) {
+      return http.request("PATCH", `/users/${seg(userId)}`, {
+        body: toBody({ ...params })
+      });
+    },
+    async delete(userId) {
+      await http.request("DELETE", `/users/${seg(userId)}`);
+    },
+    usage(params = {}) {
+      return pager(http, "/usage/end-users")({ ...params });
+    }
+  };
+}
+
+// src/resources/billing.ts
+function createBillingResource(http) {
+  return {
+    usage() {
+      return http.request("GET", "/usage/");
+    },
+    usageTimeseries(params = {}) {
+      const { agent_id, teammate_id, ...rest } = params;
+      const query = toQuery(
+        toBody({ ...rest, teammate_id: resolveAgentId(teammate_id, agent_id) })
+      );
+      return http.request("GET", "/usage/timeseries", { query });
+    },
+    receipts(params = {}) {
+      return pager(http, "/billing/receipts")({ ...params });
+    },
+    plans() {
+      return http.request("GET", "/billing/plans");
+    },
+    setOverage(params) {
+      return http.request("PATCH", "/billing/overage", { body: toBody({ ...params }) });
+    },
+    balance() {
+      return http.request("GET", "/billing/balance");
+    },
+    async topup(params) {
+      const res = await http.request("POST", "/billing/topup", {
+        body: toBody({ ...params })
+      });
+      return res.checkout_url;
+    },
+    setAutoReload(params) {
+      return http.request("PATCH", "/billing/auto-reload", {
+        body: toBody({ ...params })
+      });
+    },
+    setAlertThreshold(params) {
+      return http.request("PATCH", "/billing/alert-settings", {
+        body: toBody({ ...params })
+      });
+    }
+  };
+}
+
+// src/resources/memories.ts
+function createMemoriesResource(http) {
+  return {
+    create(params) {
+      return http.request("POST", "/memories/", { body: toBody({ ...params }) });
+    },
+    list(params = {}) {
+      return pager(http, "/memories/")({ ...params });
+    },
+    update(memoryId, { user_id, content }) {
+      return http.request("PATCH", `/memories/${seg(memoryId)}`, {
+        query: toQuery({ user_id }),
+        body: toBody({ content })
+      });
+    },
+    async delete(memoryId, params = {}) {
+      await http.request("DELETE", `/memories/${seg(memoryId)}`, {
+        query: toQuery({ user_id: params.user_id })
+      });
+    }
+  };
+}
+
+// src/resources/models.ts
+function createModelsResource(http) {
+  return {
+    async list() {
+      const res = await http.request("GET", "/models/");
+      return new Page(res?.data ?? [], res?.has_more ?? false);
+    }
+  };
+}
+
+// src/resources/model-connections.ts
+function createModelConnectionsResource(http) {
+  return {
+    async list() {
+      const res = await http.request("GET", "/model-connections/");
+      return res?.data ?? [];
+    },
+    authorize(provider) {
+      return http.request(
+        "POST",
+        `/model-connections/${seg(provider)}/authorizations`
+      );
+    },
+    authorizationStatus(provider, state) {
+      return http.request(
+        "GET",
+        `/model-connections/${seg(provider)}/authorizations/${seg(state)}`
+      );
+    },
+    completeAuthorization(provider, state, params) {
+      return http.request(
+        "POST",
+        `/model-connections/${seg(provider)}/authorizations/${seg(state)}`,
+        { body: { code: params.code } }
+      );
+    },
+    async cancelAuthorization(provider, state) {
+      await http.request("DELETE", `/model-connections/${seg(provider)}/authorizations/${seg(state)}`);
+    },
+    disconnect(provider) {
+      return http.request("DELETE", `/model-connections/${seg(provider)}`);
+    }
+  };
+}
+
+// src/resources/permissions.ts
+function createPermissionsResource(http) {
+  return {
+    create(params) {
+      return http.request("POST", "/permissions/", {
+        body: toBody({ ...params })
+      });
+    },
+    list(params) {
+      return pager(http, "/permissions/")({ ...params });
+    },
+    async delete(permissionId, params) {
+      await http.request("DELETE", `/permissions/${seg(permissionId)}`, {
+        query: toQuery({ user_id: params.user_id })
+      });
     }
   };
 }
 
+// src/mime.ts
+var EXTENSION_TYPES = Object.assign(/* @__PURE__ */ Object.create(null), {
+  // Images (the agent can actually see these via its Read tool)
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  gif: "image/gif",
+  webp: "image/webp",
+  // Documents
+  pdf: "application/pdf",
+  txt: "text/plain",
+  md: "text/markdown",
+  markdown: "text/markdown",
+  html: "text/html",
+  htm: "text/html",
+  // Code
+  py: "text/x-python",
+  js: "application/javascript",
+  mjs: "application/javascript",
+  cjs: "application/javascript",
+  json: "application/json",
+  ts: "text/typescript",
+  tsx: "text/typescript",
+  css: "text/css",
+  c: "text/x-c",
+  h: "text/x-c",
+  java: "text/x-java-source",
+  go: "text/x-go",
+  sql: "application/sql",
+  // Data / config
+  csv: "text/csv",
+  tsv: "text/csv",
+  xml: "application/xml",
+  yaml: "text/yaml",
+  yml: "text/yaml",
+  // Archives
+  zip: "application/zip",
+  gz: "application/gzip",
+  tgz: "application/gzip",
+  tar: "application/x-tar",
+  // Office
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  xls: "application/vnd.ms-excel",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ppt: "application/vnd.ms-powerpoint"
+});
+var UPLOADABLE_EXTENSIONS = Object.keys(EXTENSION_TYPES);
+function mimeTypeForFilename(name) {
+  const ext = name.includes(".") ? name.slice(name.lastIndexOf(".") + 1).toLowerCase() : "";
+  return EXTENSION_TYPES[ext];
+}
+function unknownTypeMessage(name) {
+  return `@m8tes/sdk: cannot infer a content type for "${name}", and the upload endpoint rejects files whose type it does not recognise. Pass it explicitly \u2014 { name: "${name}", data, type: "text/plain" } \u2014 or rename the file with a known extension (${UPLOADABLE_EXTENSIONS.slice(0, 12).join(", ")}, ...).`;
+}
+
+// src/polling.ts
+function isPermanent(err) {
+  return err instanceof AuthenticationError || err instanceof PermissionDeniedError || err instanceof NotFoundError || err instanceof ValidationError;
+}
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled", "closed"]);
+var BENIGN_GATE_REFUSAL_CODES = /* @__PURE__ */ new Set(["gate_cancelled", "run_not_active"]);
+var AUTO_CONTINUED_MESSAGE = "auto_continued";
+function isBenignGateRefusal(err) {
+  if (err.errorCode !== void 0) return BENIGN_GATE_REFUSAL_CODES.has(err.errorCode);
+  return err instanceof ConflictError && err.message === AUTO_CONTINUED_MESSAGE;
+}
+var RunTimeoutError = class extends Error {
+  runId;
+  timeoutSeconds;
+  /** The last error seen while polling, if any. Without it a timeout hides the
+   *  transient failure that actually caused it. */
+  cause;
+  /** The run's status when the deadline hit, when one was ever observed. */
+  lastStatus;
+  constructor(runId, timeoutSeconds, cause, lastStatus) {
+    const advice = lastStatus === "awaiting_approval" ? `The run is waiting for a human and will never finish on its own: use runs.wait() with onApproval/onQuestion, or resolve it yourself via runs.permissions(${runId}).` : `Raise the timeout, or stream the run instead of polling it.`;
+    super(
+      `Run ${runId} did not reach a terminal status within ${timeoutSeconds}s` + (lastStatus ? ` (last status: ${lastStatus})` : "") + `. ${advice}` + (cause instanceof Error ? ` Last error while polling: ${cause.message}` : "")
+    );
+    this.name = "RunTimeoutError";
+    this.runId = runId;
+    this.timeoutSeconds = timeoutSeconds;
+    this.cause = cause;
+    if (lastStatus !== void 0) this.lastStatus = lastStatus;
+  }
+};
+var RunPausedError = class extends Error {
+  runId;
+  request;
+  constructor(runId, request, hint) {
+    super(`Run ${runId} is waiting for a human: ${hint}`);
+    this.name = "RunPausedError";
+    this.runId = runId;
+    this.request = request;
+  }
+};
+function plan(options) {
+  const interval = options.interval ?? 2;
+  const timeout = options.timeout ?? 300;
+  for (const [name, value] of [["interval", interval], ["timeout", timeout]]) {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new TypeError(
+        `@m8tes/sdk: ${name} must be a finite, non-negative number of seconds (got ${String(value)}).`
+      );
+    }
+  }
+  return { interval, timeout, deadline: now() + timeout * 1e3, signal: options.signal };
+}
+function napUntil(interval, deadline, signal) {
+  const remaining = Math.max(0, deadline - now()) / 1e3;
+  return sleep(Math.min(interval, remaining), signal);
+}
+async function withDeadline(start, deadline, signal, onExpired) {
+  const remaining = deadline - now();
+  if (remaining <= 0) throw onExpired();
+  const work = start();
+  let timer;
+  let onAbort;
+  try {
+    return await Promise.race([
+      work,
+      new Promise((_, reject2) => {
+        timer = setTimeout(() => reject2(onExpired()), remaining);
+        if (signal) {
+          onAbort = () => reject2(onExpired());
+          signal.addEventListener("abort", onAbort, { once: true });
+        }
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+  }
+}
+function sleep(seconds, signal) {
+  if (signal?.aborted) return Promise.resolve();
+  return new Promise((resolve) => {
+    const timer = setTimeout(done, seconds * 1e3);
+    function done() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve();
+    }
+    signal?.addEventListener("abort", done, { once: true });
+  });
+}
+function isPlanApproval(request) {
+  if (request.tool_name !== "AskUserQuestion") return false;
+  const questions = request.tool_input?.questions;
+  return Array.isArray(questions) && questions.some((q) => q?.header === "Plan Approval");
+}
+function planText(request) {
+  if (!isPlanApproval(request)) return null;
+  const questions = request.tool_input?.questions;
+  return questions?.find((q) => q?.header === "Plan Approval")?.question ?? null;
+}
+var now = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+var RunWaitAbortedError = class extends Error {
+  /**
+   * The run being waited on — `undefined` when the abort landed BEFORE any run
+   * was created, which is the one case where there is nothing to go back to.
+   * Previously this path passed a literal 0, producing "Waiting on run 0 was
+   * aborted" and pointing the reader at a run that never existed.
+   */
+  runId;
+  constructor(runId) {
+    super(
+      runId === void 0 ? "Aborted before the run was created; nothing was started and nothing was billed." : `Waiting on run ${runId} was aborted. The run is still executing \u2014 poll it later with runs.get(${runId}), or stop it with runs.cancel(${runId}).`
+    );
+    this.name = "RunWaitAbortedError";
+    if (runId !== void 0) this.runId = runId;
+  }
+};
+async function pollRun(deps, runId, options = {}) {
+  const { interval, timeout, deadline, signal } = plan(options);
+  if (signal?.aborted) throw new RunWaitAbortedError(runId);
+  let lastError;
+  let lastStatus;
+  for (; ; ) {
+    let run;
+    try {
+      run = await withDeadline(
+        () => deps.get(runId, signal),
+        deadline,
+        signal,
+        () => signal?.aborted ? new RunWaitAbortedError(runId) : new RunTimeoutError(runId, timeout, lastError, lastStatus)
+      );
+    } catch (err) {
+      if (err instanceof RunTimeoutError || err instanceof RunWaitAbortedError) throw err;
+      if (signal?.aborted) throw new RunWaitAbortedError(runId);
+      if (isPermanent(err)) throw err;
+      lastError = err;
+      if (now() >= deadline) throw new RunTimeoutError(runId, timeout, lastError, lastStatus);
+      await napUntil(interval, deadline, signal);
+      if (signal?.aborted) throw new RunWaitAbortedError(runId);
+      if (now() >= deadline) throw new RunTimeoutError(runId, timeout, lastError, lastStatus);
+      continue;
+    }
+    lastStatus = run.status;
+    if (TERMINAL_STATUSES.has(run.status)) return run;
+    if (now() >= deadline) throw new RunTimeoutError(runId, timeout, lastError, lastStatus);
+    await napUntil(interval, deadline, signal);
+    if (signal?.aborted) throw new RunWaitAbortedError(runId);
+    if (now() >= deadline) throw new RunTimeoutError(runId, timeout, lastError, lastStatus);
+  }
+}
+async function waitForRun(deps, runId, options = {}) {
+  const { interval, timeout, deadline, signal } = plan(options);
+  if (signal?.aborted) throw new RunWaitAbortedError(runId);
+  let lastError;
+  let lastStatus;
+  const answered = /* @__PURE__ */ new Set();
+  for (; ; ) {
+    let run;
+    try {
+      run = await withDeadline(
+        () => deps.get(runId, signal),
+        deadline,
+        signal,
+        () => signal?.aborted ? new RunWaitAbortedError(runId) : new RunTimeoutError(runId, timeout, lastError, lastStatus)
+      );
+    } catch (err) {
+      if (err instanceof RunTimeoutError || err instanceof RunWaitAbortedError) throw err;
+      if (signal?.aborted) throw new RunWaitAbortedError(runId);
+      if (isPermanent(err)) throw err;
+      lastError = err;
+      if (now() >= deadline) throw new RunTimeoutError(runId, timeout, lastError, lastStatus);
+      await napUntil(interval, deadline, signal);
+      if (signal?.aborted) throw new RunWaitAbortedError(runId);
+      if (now() >= deadline) throw new RunTimeoutError(runId, timeout, lastError, lastStatus);
+      continue;
+    }
+    lastStatus = run.status;
+    if (TERMINAL_STATUSES.has(run.status)) return run;
+    if (run.status === "awaiting_approval") {
+      const expired = () => signal?.aborted ? new RunWaitAbortedError(runId) : new RunTimeoutError(runId, timeout, lastError, lastStatus);
+      const bound = (start) => withDeadline(start, deadline, signal, expired);
+      const resolveGate = async (start) => {
+        try {
+          await bound(start);
+        } catch (err) {
+          if (!(err instanceof ConflictError) && !(err instanceof NotFoundError)) throw err;
+          if (!isBenignGateRefusal(err)) throw err;
+        }
+      };
+      const pending = (await bound(() => deps.permissions(runId, signal))).filter(
+        (r) => r.status === "pending" && !answered.has(r.request_id)
+      );
+      for (const request of pending) {
+        answered.add(request.request_id);
+        if (request.tool_name === "AskUserQuestion") {
+          if (!options.onQuestion) {
+            throw new RunPausedError(
+              runId,
+              request,
+              "the agent asked a question. Pass onQuestion to answer it, or call runs.answer() yourself."
+            );
+          }
+          const answers = await bound(async () => options.onQuestion(request));
+          await resolveGate(() => deps.answer(runId, { answers }, signal));
+        } else {
+          if (!options.onApproval) {
+            throw new RunPausedError(
+              runId,
+              request,
+              `the tool "${request.tool_name}" needs a decision. Pass onApproval, or call runs.approve() yourself.`
+            );
+          }
+          const decision = await bound(async () => options.onApproval(request));
+          await resolveGate(() => deps.approve(runId, { request_id: request.request_id, decision }, signal));
+        }
+      }
+    }
+    if (now() >= deadline) throw new RunTimeoutError(runId, timeout, lastError, lastStatus);
+    await napUntil(interval, deadline, signal);
+    if (signal?.aborted) throw new RunWaitAbortedError(runId);
+    if (now() >= deadline) throw new RunTimeoutError(runId, timeout, lastError, lastStatus);
+  }
+}
+
 // src/streaming.ts
 var RunStream = class {
   source;
@@ -1466,29 +1988,114 @@ var RunStream = class {
 };
 
 // src/resources/runs.ts
+function withRunId(err, runId) {
+  if (err && typeof err === "object" && !("runId" in err)) {
+    Object.defineProperty(err, "runId", { value: runId, enumerable: true, configurable: true });
+    const e = err;
+    if (typeof e.message === "string" && !e.message.includes(String(runId))) {
+      e.message = `${e.message} (while waiting on run ${runId}, which is still executing)`;
+    }
+  }
+  return err;
+}
 function items(payload) {
   return Array.isArray(payload) ? payload : payload?.data ?? [];
 }
+function idempotencyHeaders(key) {
+  return { [IDEMPOTENCY_HEADER]: key ?? crypto.randomUUID() };
+}
+function replayJoin(http) {
+  return async function* (run) {
+    if (TERMINAL_STATUSES.has(run.status)) {
+      throw new ConflictError(
+        `Run ${run.id} was already created by an earlier attempt with this idempotency key and has finished (status=${run.status}), so there is no stream to join. You were charged once. Fetch the result with runs.get(${run.id}).`,
+        {
+          type: "invalid_request_error",
+          code: 409,
+          status: 409,
+          details: { error_code: "idempotent_replay_terminal", run_id: run.id, status: run.status }
+        }
+      );
+    }
+    yield* http.stream("GET", `/runs/${seg(run.id)}/stream`);
+  };
+}
 function createRunsResource(http) {
   const createBody = (p, stream) => {
-    const { agent_id, teammate_id, ...rest } = p;
+    const { agent_id, teammate_id, files, idempotencyKey, ...rest } = p;
     return toBody({ ...rest, teammate_id: resolveAgentId(teammate_id, agent_id), stream });
   };
+  const createForm = (p, stream) => {
+    const form = new FormData();
+    form.append("payload", JSON.stringify(createBody(p, stream)));
+    for (const f of p.files ?? []) {
+      const blobType = f.data instanceof Blob && f.data.type ? f.data.type : void 0;
+      const type = f.type ?? blobType ?? mimeTypeForFilename(f.name);
+      if (!type) throw new TypeError(unknownTypeMessage(f.name));
+      const blob = f.data instanceof Blob && f.data.type === type ? f.data : new Blob([f.data], { type });
+      form.append("files", blob, f.name);
+    }
+    return form;
+  };
+  const hasFiles = (p) => (p.files?.length ?? 0) > 0;
+  const deps = {
+    get: (runId, signal) => http.request("GET", `/runs/${seg(runId)}`, { signal }),
+    permissions: async (runId, signal) => items(await http.request("GET", `/runs/${seg(runId)}/permissions`, { signal })),
+    approve: (runId, params, signal) => http.request("POST", `/runs/${seg(runId)}/approve`, { body: { remember: false, ...params }, signal }),
+    answer: (runId, params, signal) => http.request("POST", `/runs/${seg(runId)}/answer`, { body: params, signal })
+  };
+  const createAsync = async (params) => {
+    const headers = idempotencyHeaders(params.idempotencyKey);
+    return hasFiles(params) ? http.request("POST", "/runs/with-files", { form: createForm(params, false), headers }) : http.request("POST", "/runs", { body: createBody(params, false), headers });
+  };
   return {
     create(params, options) {
-      return new RunStream(http.stream("POST", "/runs", { body: createBody(params, true) }), options);
+      const headers = idempotencyHeaders(params.idempotencyKey);
+      const init = hasFiles(params) ? { form: createForm(params, true), headers } : { body: createBody(params, true), headers };
+      const path = hasFiles(params) ? "/runs/with-files" : "/runs";
+      return new RunStream(
+        http.stream("POST", path, { ...init, onReplay: replayJoin(http) }),
+        options
+      );
+    },
+    createAsync,
+    async createAndWait(params, options = {}) {
+      if (options.signal?.aborted) throw new RunWaitAbortedError();
+      const started = await createAsync(params);
+      try {
+        return await waitForRun(deps, started.id, options);
+      } catch (err) {
+        throw withRunId(err, started.id);
+      }
+    },
+    poll(runId, options) {
+      return pollRun(deps, runId, options);
     },
-    createAsync(params) {
-      return http.request("POST", "/runs", { body: createBody(params, false) });
+    wait(runId, options) {
+      return waitForRun(deps, runId, options);
+    },
+    // `confirm` is a QUERY param and the route takes no body (verified against
+    // fastapi/app/routers/v2/runs.py::retry_run), so send neither.
+    retry(runId, params = {}) {
+      return http.request("POST", `/runs/${seg(runId)}/retry`, {
+        query: params.confirm ? toQuery({ confirm: true }) : ""
+      });
     },
     stream(runId, options) {
-      return new RunStream(http.stream("GET", `/runs/${runId}/stream`), options);
+      return new RunStream(http.stream("GET", `/runs/${seg(runId)}/stream`), options);
     },
     reply(runId, message, options) {
-      return new RunStream(http.stream("POST", `/runs/${runId}/reply`, { body: { message } }), options);
+      return new RunStream(
+        http.stream("POST", `/runs/${seg(runId)}/reply`, {
+          body: { message },
+          headers: idempotencyHeaders(options?.idempotencyKey),
+          onReplay: replayJoin(http)
+        }),
+        options
+      );
     },
     get(runId) {
-      return http.request("GET", `/runs/${runId}`);
+      return http.request("GET", `/runs/${seg(runId)}`);
     },
     async list(params = {}) {
       const { agent_id, teammate_id, ...rest } = params;
@@ -1506,29 +2113,29 @@ function createRunsResource(http) {
       return fetchPage(q);
     },
     cancel(runId) {
-      return http.request("POST", `/runs/${runId}/cancel`, { body: {} });
+      return http.request("POST", `/runs/${seg(runId)}/cancel`, { body: {} });
     },
     approve(runId, params) {
-      return http.request("POST", `/runs/${runId}/approve`, {
+      return http.request("POST", `/runs/${seg(runId)}/approve`, {
         body: { remember: false, ...params }
       });
     },
     answer(runId, params) {
-      return http.request("POST", `/runs/${runId}/answer`, {
+      return http.request("POST", `/runs/${seg(runId)}/answer`, {
         body: { answers: params.answers }
       });
     },
     async permissions(runId) {
-      return items(await http.request("GET", `/runs/${runId}/permissions`));
+      return items(await http.request("GET", `/runs/${seg(runId)}/permissions`));
     },
     outcome(runId) {
-      return http.request("GET", `/runs/${runId}/outcome`);
+      return http.request("GET", `/runs/${seg(runId)}/outcome`);
     },
     async files(runId) {
-      return items(await http.request("GET", `/runs/${runId}/files`));
+      return items(await http.request("GET", `/runs/${seg(runId)}/files`));
     },
     async downloadFile(runId, filename) {
-      const res = await http.raw("GET", `/runs/${runId}/files/${encodeURIComponent(filename)}/download`, {
+      const res = await http.raw("GET", `/runs/${seg(runId)}/files/${seg(filename)}/download`, {
         headers: { accept: "application/octet-stream" }
       });
       return res.arrayBuffer();
@@ -1553,24 +2160,30 @@ function createSettingsResource(http) {
 function createTasksResource(http) {
   const triggers = {
     create(taskId, params) {
-      return http.request("POST", `/tasks/${taskId}/triggers/`, {
-        body: toBody({ timezone: "UTC", ...params })
+      return http.request("POST", `/tasks/${seg(taskId)}/triggers/`, {
+        body: toBody({ timezone: "UTC", ...params }),
+        query: toQuery({ user_id: params.user_id })
       });
     },
-    async list(taskId) {
+    async list(taskId, params = {}) {
       const res = await http.request(
         "GET",
-        `/tasks/${taskId}/triggers/`
+        `/tasks/${seg(taskId)}/triggers/`,
+        { query: toQuery(params) }
       );
       return Array.isArray(res) ? res : res?.data ?? [];
     },
     update(taskId, triggerId, params) {
-      return http.request("PATCH", `/tasks/${taskId}/triggers/${triggerId}`, {
-        body: toBody({ ...params })
+      const { user_id, ...patch } = params;
+      return http.request("PATCH", `/tasks/${seg(taskId)}/triggers/${seg(triggerId)}`, {
+        body: toBody(patch),
+        query: toQuery({ user_id })
       });
     },
-    async delete(taskId, triggerId) {
-      await http.request("DELETE", `/tasks/${taskId}/triggers/${triggerId}`);
+    async delete(taskId, triggerId, params = {}) {
+      await http.request("DELETE", `/tasks/${seg(taskId)}/triggers/${seg(triggerId)}`, {
+        query: toQuery(params)
+      });
     }
   };
   return {
@@ -1597,73 +2210,46 @@ function createTasksResource(http) {
       return fetchPage(q);
     },
     get(taskId, params = {}) {
-      return http.request("GET", `/tasks/${taskId}`, { query: toQuery(params) });
+      return http.request("GET", `/tasks/${seg(taskId)}`, { query: toQuery(params) });
     },
     update(taskId, params) {
       const { user_id, ...patch } = params;
-      return http.request("PATCH", `/tasks/${taskId}`, {
+      return http.request("PATCH", `/tasks/${seg(taskId)}`, {
         body: toBody(patch),
         query: toQuery({ user_id })
       });
     },
     async delete(taskId, params = {}) {
-      await http.request("DELETE", `/tasks/${taskId}`, { query: toQuery(params) });
+      await http.request("DELETE", `/tasks/${seg(taskId)}`, { query: toQuery(params) });
     },
     run(taskId, params = {}, options) {
+      const { idempotencyKey, ...rest } = params;
       return new RunStream(
-        http.stream("POST", `/tasks/${taskId}/runs`, { body: toBody({ ...params, stream: true }) }),
+        http.stream("POST", `/tasks/${seg(taskId)}/runs`, {
+          body: toBody({ ...rest, stream: true }),
+          headers: idempotencyHeaders(idempotencyKey),
+          // Shares the create path's replay handling, so a fix on one side can
+          // never silently miss the other.
+          onReplay: replayJoin(http)
+        }),
         options
       );
     },
     runAsync(taskId, params = {}) {
-      return http.request("POST", `/tasks/${taskId}/runs`, {
-        body: toBody({ ...params, stream: false })
+      const { idempotencyKey, ...rest } = params;
+      return http.request("POST", `/tasks/${seg(taskId)}/runs`, {
+        body: toBody({ ...rest, stream: false }),
+        headers: idempotencyHeaders(idempotencyKey)
       });
     },
-    enableWebhook(taskId) {
-      return http.request("POST", `/tasks/${taskId}/webhook`, { body: {} });
-    },
-    async disableWebhook(taskId) {
-      await http.request("DELETE", `/tasks/${taskId}/webhook`);
-    }
-  };
-}
-
-// src/resources/users.ts
-function pager(http, path) {
-  const fetchPage = async (p) => {
-    const res = await http.request("GET", path, {
-      query: toQuery(p)
-    });
-    return new Page(
-      res?.data ?? [],
-      res?.has_more ?? false,
-      (starting_after) => fetchPage({ ...p, starting_after })
-    );
-  };
-  return fetchPage;
-}
-function createUsersResource(http) {
-  return {
-    create(params) {
-      return http.request("POST", "/users/", { body: toBody({ ...params }) });
-    },
-    list(params = {}) {
-      return pager(http, "/users/")({ ...params });
-    },
-    get(userId) {
-      return http.request("GET", `/users/${encodeURIComponent(userId)}`);
-    },
-    update(userId, params) {
-      return http.request("PATCH", `/users/${encodeURIComponent(userId)}`, {
-        body: toBody({ ...params })
+    enableWebhook(taskId, params = {}) {
+      return http.request("POST", `/tasks/${seg(taskId)}/webhook`, {
+        body: {},
+        query: toQuery(params)
       });
     },
-    async delete(userId) {
-      await http.request("DELETE", `/users/${encodeURIComponent(userId)}`);
-    },
-    usage(params = {}) {
-      return pager(http, "/usage/end-users")({ ...params });
+    async disableWebhook(taskId, params = {}) {
+      await http.request("DELETE", `/tasks/${seg(taskId)}/webhook`, { query: toQuery(params) });
     }
   };
 }
@@ -1687,14 +2273,14 @@ function verifySignature(body, headers, secret, options = {}) {
   if (options.toleranceSeconds !== void 0) {
     const ts = Number.parseInt(timestamp, 10);
     if (!Number.isFinite(ts)) return false;
-    const now = options.now ? options.now() : Math.floor(Date.now() / 1e3);
-    if (Math.abs(now - ts) > options.toleranceSeconds) return false;
+    const now2 = options.now ? options.now() : Math.floor(Date.now() / 1e3);
+    if (Math.abs(now2 - ts) > options.toleranceSeconds) return false;
   }
   const raw = typeof body === "string" ? body : new TextDecoder().decode(body);
-  const expected = `v1=${crypto.createHmac("sha256", secret).update(`${webhookId}.${timestamp}.${raw}`).digest("hex")}`;
+  const expected = `v1=${crypto$1.createHmac("sha256", secret).update(`${webhookId}.${timestamp}.${raw}`).digest("hex")}`;
   const a = Buffer.from(expected);
   const b = Buffer.from(signature);
-  return a.length === b.length && crypto.timingSafeEqual(a, b);
+  return a.length === b.length && crypto$1.timingSafeEqual(a, b);
 }
 function createWebhooksResource(http) {
   return {
@@ -1706,22 +2292,22 @@ function createWebhooksResource(http) {
       return pager(http, "/webhooks/")({ ...params });
     },
     get(webhookId) {
-      return http.request("GET", `/webhooks/${webhookId}`);
+      return http.request("GET", `/webhooks/${seg(webhookId)}`);
     },
     update(webhookId, params) {
-      return http.request("PATCH", `/webhooks/${webhookId}`, { body: toBody({ ...params }) });
+      return http.request("PATCH", `/webhooks/${seg(webhookId)}`, { body: toBody({ ...params }) });
     },
     async delete(webhookId) {
-      await http.request("DELETE", `/webhooks/${webhookId}`);
+      await http.request("DELETE", `/webhooks/${seg(webhookId)}`);
     },
     listDeliveries(webhookId, params = {}) {
-      return pager(http, `/webhooks/${webhookId}/deliveries`)({ ...params });
+      return pager(http, `/webhooks/${seg(webhookId)}/deliveries`)({ ...params });
     }
   };
 }
 
 // src/index.ts
-var M8TES_SDK_VERSION = "0.1.0-alpha.1";
+var M8TES_SDK_VERSION = "0.1.0-alpha.2";
 var M8tes = class {
   runs;
   agents;
@@ -1732,6 +2318,12 @@ var M8tes = class {
   apps;
   webhooks;
   settings;
+  memories;
+  permissions;
+  models;
+  modelConnections;
+  billing;
+  account;
   /** The underlying transport. Use it to call an endpoint this version does not wrap yet. */
   http;
   constructor(options = {}) {
@@ -1744,6 +2336,12 @@ var M8tes = class {
     this.apps = createAppsResource(this.http);
     this.webhooks = createWebhooksResource(this.http);
     this.settings = createSettingsResource(this.http);
+    this.memories = createMemoriesResource(this.http);
+    this.permissions = createPermissionsResource(this.http);
+    this.models = createModelsResource(this.http);
+    this.modelConnections = createModelConnectionsResource(this.http);
+    this.billing = createBillingResource(this.http);
+    this.account = createAccountResource(this.http);
   }
 };
 
@@ -1762,8 +2360,12 @@ exports.PermissionDeniedError = PermissionDeniedError;
 exports.RateLimitError = RateLimitError;
 exports.RunFailedError = RunFailedError;
 exports.RunNotStreamingError = RunNotStreamingError;
+exports.RunPausedError = RunPausedError;
 exports.RunStream = RunStream;
+exports.RunTimeoutError = RunTimeoutError;
+exports.RunWaitAbortedError = RunWaitAbortedError;
 exports.TERMINAL_EVENT_TYPES = TERMINAL_EVENT_TYPES;
+exports.TERMINAL_STATUSES = TERMINAL_STATUSES;
 exports.ValidationError = ValidationError;
 exports.accumulate = accumulate;
 exports.createAccumulator = createAccumulator;
@@ -1773,11 +2375,16 @@ exports.createSseDecoder = createSseDecoder;
 exports.errorClassForStatus = errorClassForStatus;
 exports.errorFromResponse = errorFromResponse;
 exports.initialConversationState = initialConversationState;
+exports.isPlanApproval = isPlanApproval;
 exports.isTerminalEvent = isTerminalEvent;
 exports.parseErrorEnvelope = parseErrorEnvelope;
 exports.parseRetryAfter = parseRetryAfter;
 exports.parseSse = parseSse;
+exports.planText = planText;
+exports.pollRun = pollRun;
+exports.seg = seg;
 exports.splitConcatenatedJson = splitConcatenatedJson;
 exports.verifySignature = verifySignature;
+exports.waitForRun = waitForRun;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map