@letta-ai/letta-agent-sdk 0.5.0 → 0.5.2

package/dist/client-entry.js

@@ -1,71 +1,2818 @@
 // Generated bundle. Canonical modules are published under src/ and maintained in the letta-agent-sdk repository.
 
-// src/repositories.ts
-var DEFAULT_CLOUD_API_BASE_URL = "https://api.letta.com";
-function getDefaultApiKey() {
-  const env = globalThis.process?.env;
-  return env?.LETTA_API_KEY ?? env?.LETTA_CLOUD_API_KEY;
+// node_modules/@letta-ai/letta-client/internal/tslib.mjs
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+  if (kind === "m")
+    throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f)
+    throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+    throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+}
+function __classPrivateFieldGet(receiver, state, kind, f) {
+  if (kind === "a" && !f)
+    throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+    throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+// node_modules/@letta-ai/letta-client/internal/utils/uuid.mjs
+var uuid4 = function() {
+  const { crypto } = globalThis;
+  if (crypto?.randomUUID) {
+    uuid4 = crypto.randomUUID.bind(crypto);
+    return crypto.randomUUID();
+  }
+  const u8 = new Uint8Array(1);
+  const randomByte = crypto ? () => crypto.getRandomValues(u8)[0] : () => Math.random() * 255 & 255;
+  return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (c) => (+c ^ randomByte() & 15 >> +c / 4).toString(16));
+};
+
+// node_modules/@letta-ai/letta-client/internal/errors.mjs
+function isAbortError(err) {
+  return typeof err === "object" && err !== null && (("name" in err) && err.name === "AbortError" || ("message" in err) && String(err.message).includes("FetchRequestCanceledException"));
 }
-function bearerTokenFromHeaders(headers) {
-  const authorization = headers?.Authorization ?? headers?.authorization;
-  if (!authorization)
-    return;
-  const match = /^Bearer\s+(.+)$/i.exec(authorization);
-  return match?.[1];
+var castToError = (err) => {
+  if (err instanceof Error)
+    return err;
+  if (typeof err === "object" && err !== null) {
+    try {
+      if (Object.prototype.toString.call(err) === "[object Error]") {
+        const error = new Error(err.message, err.cause ? { cause: err.cause } : {});
+        if (err.stack)
+          error.stack = err.stack;
+        if (err.cause && !error.cause)
+          error.cause = err.cause;
+        if (err.name)
+          error.name = err.name;
+        return error;
+      }
+    } catch {}
+    try {
+      return new Error(JSON.stringify(err));
+    } catch {}
+  }
+  return new Error(err);
+};
+
+// node_modules/@letta-ai/letta-client/core/error.mjs
+class LettaError extends Error {
 }
-function getCloudApiKey(options) {
-  return options.apiKey ?? bearerTokenFromHeaders(options.headers) ?? getDefaultApiKey();
+
+class APIError extends LettaError {
+  constructor(status, error, message, headers) {
+    super(`${APIError.makeMessage(status, error, message)}`);
+    this.status = status;
+    this.headers = headers;
+    this.error = error;
+  }
+  static makeMessage(status, error, message) {
+    const msg = error?.message ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : error ? JSON.stringify(error) : message;
+    if (status && msg) {
+      return `${status} ${msg}`;
+    }
+    if (status) {
+      return `${status} status code (no body)`;
+    }
+    if (msg) {
+      return msg;
+    }
+    return "(no status code or body)";
+  }
+  static generate(status, errorResponse, message, headers) {
+    if (!status || !headers) {
+      return new APIConnectionError({ message, cause: castToError(errorResponse) });
+    }
+    const error = errorResponse;
+    if (status === 400) {
+      return new BadRequestError(status, error, message, headers);
+    }
+    if (status === 401) {
+      return new AuthenticationError(status, error, message, headers);
+    }
+    if (status === 403) {
+      return new PermissionDeniedError(status, error, message, headers);
+    }
+    if (status === 404) {
+      return new NotFoundError(status, error, message, headers);
+    }
+    if (status === 409) {
+      return new ConflictError(status, error, message, headers);
+    }
+    if (status === 422) {
+      return new UnprocessableEntityError(status, error, message, headers);
+    }
+    if (status === 429) {
+      return new RateLimitError(status, error, message, headers);
+    }
+    if (status >= 500) {
+      return new InternalServerError(status, error, message, headers);
+    }
+    return new APIError(status, error, message, headers);
+  }
 }
-function getFetch(fetchOverride) {
-  const resolved = fetchOverride ?? globalThis.fetch;
-  if (!resolved)
-    throw new Error("No fetch implementation available for cloud backend.");
-  return resolved.bind(globalThis);
+
+class APIUserAbortError extends APIError {
+  constructor({ message } = {}) {
+    super(undefined, undefined, message || "Request was aborted.", undefined);
+  }
 }
-function normalizeCloudApiBaseUrl(url) {
-  const parsed = new URL(url ?? DEFAULT_CLOUD_API_BASE_URL);
-  parsed.pathname = parsed.pathname.replace(/\/+$/, "");
-  parsed.search = "";
-  parsed.hash = "";
-  return parsed.toString().replace(/\/$/, "");
+
+class APIConnectionError extends APIError {
+  constructor({ message, cause }) {
+    super(undefined, undefined, message || "Connection error.", undefined);
+    if (cause)
+      this.cause = cause;
+  }
 }
-function cloudHeaders(options) {
-  const headers = {
-    "Content-Type": "application/json",
-    ...options.headers ?? {}
-  };
-  const apiKey = getCloudApiKey(options);
-  if (apiKey && !headers.Authorization && !headers.authorization) {
-    headers.Authorization = `Bearer ${apiKey}`;
+
+class APIConnectionTimeoutError extends APIConnectionError {
+  constructor({ message } = {}) {
+    super({ message: message ?? "Request timed out." });
   }
-  return headers;
 }
-async function parseJsonResponse(response) {
-  const text = await response.text();
-  if (!text)
-    return null;
+
+class BadRequestError extends APIError {
+}
+
+class AuthenticationError extends APIError {
+}
+
+class PermissionDeniedError extends APIError {
+}
+
+class NotFoundError extends APIError {
+}
+
+class ConflictError extends APIError {
+}
+
+class UnprocessableEntityError extends APIError {
+}
+
+class RateLimitError extends APIError {
+}
+
+class InternalServerError extends APIError {
+}
+
+// node_modules/@letta-ai/letta-client/internal/utils/values.mjs
+var startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i;
+var isAbsoluteURL = (url) => {
+  return startsWithSchemeRegexp.test(url);
+};
+var isArray = (val) => (isArray = Array.isArray, isArray(val));
+var isReadonlyArray = isArray;
+function maybeObj(x) {
+  if (typeof x !== "object") {
+    return {};
+  }
+  return x ?? {};
+}
+function isEmptyObj(obj) {
+  if (!obj)
+    return true;
+  for (const _k in obj)
+    return false;
+  return true;
+}
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+var validatePositiveInteger = (name, n) => {
+  if (typeof n !== "number" || !Number.isInteger(n)) {
+    throw new LettaError(`${name} must be an integer`);
+  }
+  if (n < 0) {
+    throw new LettaError(`${name} must be a positive integer`);
+  }
+  return n;
+};
+var safeJSON = (text) => {
   try {
     return JSON.parse(text);
-  } catch {
-    return text;
+  } catch (err) {
+    return;
+  }
+};
+
+// node_modules/@letta-ai/letta-client/internal/utils/sleep.mjs
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// node_modules/@letta-ai/letta-client/version.mjs
+var VERSION = "1.12.1";
+
+// node_modules/@letta-ai/letta-client/internal/detect-platform.mjs
+function getDetectedPlatform() {
+  if (typeof Deno !== "undefined" && Deno.build != null) {
+    return "deno";
+  }
+  if (typeof EdgeRuntime !== "undefined") {
+    return "edge";
+  }
+  if (Object.prototype.toString.call(typeof globalThis.process !== "undefined" ? globalThis.process : 0) === "[object process]") {
+    return "node";
+  }
+  return "unknown";
+}
+var getPlatformProperties = () => {
+  const detectedPlatform = getDetectedPlatform();
+  if (detectedPlatform === "deno") {
+    return {
+      "X-Stainless-Lang": "js",
+      "X-Stainless-Package-Version": VERSION,
+      "X-Stainless-OS": normalizePlatform(Deno.build.os),
+      "X-Stainless-Arch": normalizeArch(Deno.build.arch),
+      "X-Stainless-Runtime": "deno",
+      "X-Stainless-Runtime-Version": typeof Deno.version === "string" ? Deno.version : Deno.version?.deno ?? "unknown"
+    };
+  }
+  if (typeof EdgeRuntime !== "undefined") {
+    return {
+      "X-Stainless-Lang": "js",
+      "X-Stainless-Package-Version": VERSION,
+      "X-Stainless-OS": "Unknown",
+      "X-Stainless-Arch": `other:${EdgeRuntime}`,
+      "X-Stainless-Runtime": "edge",
+      "X-Stainless-Runtime-Version": globalThis.process.version
+    };
+  }
+  if (detectedPlatform === "node") {
+    return {
+      "X-Stainless-Lang": "js",
+      "X-Stainless-Package-Version": VERSION,
+      "X-Stainless-OS": normalizePlatform(globalThis.process.platform ?? "unknown"),
+      "X-Stainless-Arch": normalizeArch(globalThis.process.arch ?? "unknown"),
+      "X-Stainless-Runtime": "node",
+      "X-Stainless-Runtime-Version": globalThis.process.version ?? "unknown"
+    };
+  }
+  const browserInfo = getBrowserInfo();
+  if (browserInfo) {
+    return {
+      "X-Stainless-Lang": "js",
+      "X-Stainless-Package-Version": VERSION,
+      "X-Stainless-OS": "Unknown",
+      "X-Stainless-Arch": "unknown",
+      "X-Stainless-Runtime": `browser:${browserInfo.browser}`,
+      "X-Stainless-Runtime-Version": browserInfo.version
+    };
+  }
+  return {
+    "X-Stainless-Lang": "js",
+    "X-Stainless-Package-Version": VERSION,
+    "X-Stainless-OS": "Unknown",
+    "X-Stainless-Arch": "unknown",
+    "X-Stainless-Runtime": "unknown",
+    "X-Stainless-Runtime-Version": "unknown"
+  };
+};
+function getBrowserInfo() {
+  if (typeof navigator === "undefined" || !navigator) {
+    return null;
+  }
+  const browserPatterns = [
+    { key: "edge", pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: "ie", pattern: /MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: "ie", pattern: /Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: "chrome", pattern: /Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: "firefox", pattern: /Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+    { key: "safari", pattern: /(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/ }
+  ];
+  for (const { key, pattern } of browserPatterns) {
+    const match = pattern.exec(navigator.userAgent);
+    if (match) {
+      const major = match[1] || 0;
+      const minor = match[2] || 0;
+      const patch = match[3] || 0;
+      return { browser: key, version: `${major}.${minor}.${patch}` };
+    }
+  }
+  return null;
+}
+var normalizeArch = (arch) => {
+  if (arch === "x32")
+    return "x32";
+  if (arch === "x86_64" || arch === "x64")
+    return "x64";
+  if (arch === "arm")
+    return "arm";
+  if (arch === "aarch64" || arch === "arm64")
+    return "arm64";
+  if (arch)
+    return `other:${arch}`;
+  return "unknown";
+};
+var normalizePlatform = (platform) => {
+  platform = platform.toLowerCase();
+  if (platform.includes("ios"))
+    return "iOS";
+  if (platform === "android")
+    return "Android";
+  if (platform === "darwin")
+    return "MacOS";
+  if (platform === "win32")
+    return "Windows";
+  if (platform === "freebsd")
+    return "FreeBSD";
+  if (platform === "openbsd")
+    return "OpenBSD";
+  if (platform === "linux")
+    return "Linux";
+  if (platform)
+    return `Other:${platform}`;
+  return "Unknown";
+};
+var _platformHeaders;
+var getPlatformHeaders = () => {
+  return _platformHeaders ?? (_platformHeaders = getPlatformProperties());
+};
+
+// node_modules/@letta-ai/letta-client/internal/shims.mjs
+function getDefaultFetch() {
+  if (typeof fetch !== "undefined") {
+    return fetch;
+  }
+  throw new Error("`fetch` is not defined as a global; Either pass `fetch` to the client, `new Letta({ fetch })` or polyfill the global, `globalThis.fetch = fetch`");
+}
+function makeReadableStream(...args) {
+  const ReadableStream = globalThis.ReadableStream;
+  if (typeof ReadableStream === "undefined") {
+    throw new Error("`ReadableStream` is not defined as a global; You will need to polyfill it, `globalThis.ReadableStream = ReadableStream`");
+  }
+  return new ReadableStream(...args);
+}
+function ReadableStreamFrom(iterable) {
+  let iter = Symbol.asyncIterator in iterable ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
+  return makeReadableStream({
+    start() {},
+    async pull(controller) {
+      const { done, value } = await iter.next();
+      if (done) {
+        controller.close();
+      } else {
+        controller.enqueue(value);
+      }
+    },
+    async cancel() {
+      await iter.return?.();
+    }
+  });
+}
+function ReadableStreamToAsyncIterable(stream) {
+  if (stream[Symbol.asyncIterator])
+    return stream;
+  const reader = stream.getReader();
+  return {
+    async next() {
+      try {
+        const result = await reader.read();
+        if (result?.done)
+          reader.releaseLock();
+        return result;
+      } catch (e) {
+        reader.releaseLock();
+        throw e;
+      }
+    },
+    async return() {
+      const cancelPromise = reader.cancel();
+      reader.releaseLock();
+      await cancelPromise;
+      return { done: true, value: undefined };
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+}
+async function CancelReadableStream(stream) {
+  if (stream === null || typeof stream !== "object")
+    return;
+  if (stream[Symbol.asyncIterator]) {
+    await stream[Symbol.asyncIterator]().return?.();
+    return;
+  }
+  const reader = stream.getReader();
+  const cancelPromise = reader.cancel();
+  reader.releaseLock();
+  await cancelPromise;
+}
+
+// node_modules/@letta-ai/letta-client/internal/request-options.mjs
+var FallbackEncoder = ({ headers, body }) => {
+  return {
+    bodyHeaders: {
+      "content-type": "application/json"
+    },
+    body: JSON.stringify(body)
+  };
+};
+
+// node_modules/@letta-ai/letta-client/internal/qs/formats.mjs
+var default_format = "RFC3986";
+var default_formatter = (v) => String(v);
+var formatters = {
+  RFC1738: (v) => String(v).replace(/%20/g, "+"),
+  RFC3986: default_formatter
+};
+var RFC1738 = "RFC1738";
+
+// node_modules/@letta-ai/letta-client/internal/qs/utils.mjs
+var has = (obj, key) => (has = Object.hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty), has(obj, key));
+var hex_table = /* @__PURE__ */ (() => {
+  const array = [];
+  for (let i = 0;i < 256; ++i) {
+    array.push("%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase());
+  }
+  return array;
+})();
+var limit = 1024;
+var encode = (str, _defaultEncoder, charset, _kind, format) => {
+  if (str.length === 0) {
+    return str;
+  }
+  let string = str;
+  if (typeof str === "symbol") {
+    string = Symbol.prototype.toString.call(str);
+  } else if (typeof str !== "string") {
+    string = String(str);
+  }
+  if (charset === "iso-8859-1") {
+    return escape(string).replace(/%u[0-9a-f]{4}/gi, function($0) {
+      return "%26%23" + parseInt($0.slice(2), 16) + "%3B";
+    });
+  }
+  let out = "";
+  for (let j = 0;j < string.length; j += limit) {
+    const segment = string.length >= limit ? string.slice(j, j + limit) : string;
+    const arr = [];
+    for (let i = 0;i < segment.length; ++i) {
+      let c = segment.charCodeAt(i);
+      if (c === 45 || c === 46 || c === 95 || c === 126 || c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || format === RFC1738 && (c === 40 || c === 41)) {
+        arr[arr.length] = segment.charAt(i);
+        continue;
+      }
+      if (c < 128) {
+        arr[arr.length] = hex_table[c];
+        continue;
+      }
+      if (c < 2048) {
+        arr[arr.length] = hex_table[192 | c >> 6] + hex_table[128 | c & 63];
+        continue;
+      }
+      if (c < 55296 || c >= 57344) {
+        arr[arr.length] = hex_table[224 | c >> 12] + hex_table[128 | c >> 6 & 63] + hex_table[128 | c & 63];
+        continue;
+      }
+      i += 1;
+      c = 65536 + ((c & 1023) << 10 | segment.charCodeAt(i) & 1023);
+      arr[arr.length] = hex_table[240 | c >> 18] + hex_table[128 | c >> 12 & 63] + hex_table[128 | c >> 6 & 63] + hex_table[128 | c & 63];
+    }
+    out += arr.join("");
+  }
+  return out;
+};
+function is_buffer(obj) {
+  if (!obj || typeof obj !== "object") {
+    return false;
+  }
+  return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
+}
+function maybe_map(val, fn) {
+  if (isArray(val)) {
+    const mapped = [];
+    for (let i = 0;i < val.length; i += 1) {
+      mapped.push(fn(val[i]));
+    }
+    return mapped;
+  }
+  return fn(val);
+}
+
+// node_modules/@letta-ai/letta-client/internal/qs/stringify.mjs
+var array_prefix_generators = {
+  brackets(prefix) {
+    return String(prefix) + "[]";
+  },
+  comma: "comma",
+  indices(prefix, key) {
+    return String(prefix) + "[" + key + "]";
+  },
+  repeat(prefix) {
+    return String(prefix);
+  }
+};
+var push_to_array = function(arr, value_or_array) {
+  Array.prototype.push.apply(arr, isArray(value_or_array) ? value_or_array : [value_or_array]);
+};
+var toISOString;
+var defaults = {
+  addQueryPrefix: false,
+  allowDots: false,
+  allowEmptyArrays: false,
+  arrayFormat: "indices",
+  charset: "utf-8",
+  charsetSentinel: false,
+  delimiter: "&",
+  encode: true,
+  encodeDotInKeys: false,
+  encoder: encode,
+  encodeValuesOnly: false,
+  format: default_format,
+  formatter: default_formatter,
+  indices: false,
+  serializeDate(date) {
+    return (toISOString ?? (toISOString = Function.prototype.call.bind(Date.prototype.toISOString)))(date);
+  },
+  skipNulls: false,
+  strictNullHandling: false
+};
+function is_non_nullish_primitive(v) {
+  return typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "symbol" || typeof v === "bigint";
+}
+var sentinel = {};
+function inner_stringify(object, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, sideChannel) {
+  let obj = object;
+  let tmp_sc = sideChannel;
+  let step = 0;
+  let find_flag = false;
+  while ((tmp_sc = tmp_sc.get(sentinel)) !== undefined && !find_flag) {
+    const pos = tmp_sc.get(object);
+    step += 1;
+    if (typeof pos !== "undefined") {
+      if (pos === step) {
+        throw new RangeError("Cyclic object value");
+      } else {
+        find_flag = true;
+      }
+    }
+    if (typeof tmp_sc.get(sentinel) === "undefined") {
+      step = 0;
+    }
+  }
+  if (typeof filter === "function") {
+    obj = filter(prefix, obj);
+  } else if (obj instanceof Date) {
+    obj = serializeDate?.(obj);
+  } else if (generateArrayPrefix === "comma" && isArray(obj)) {
+    obj = maybe_map(obj, function(value) {
+      if (value instanceof Date) {
+        return serializeDate?.(value);
+      }
+      return value;
+    });
+  }
+  if (obj === null) {
+    if (strictNullHandling) {
+      return encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset, "key", format) : prefix;
+    }
+    obj = "";
+  }
+  if (is_non_nullish_primitive(obj) || is_buffer(obj)) {
+    if (encoder) {
+      const key_value = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, "key", format);
+      return [
+        formatter?.(key_value) + "=" + formatter?.(encoder(obj, defaults.encoder, charset, "value", format))
+      ];
+    }
+    return [formatter?.(prefix) + "=" + formatter?.(String(obj))];
+  }
+  const values = [];
+  if (typeof obj === "undefined") {
+    return values;
+  }
+  let obj_keys;
+  if (generateArrayPrefix === "comma" && isArray(obj)) {
+    if (encodeValuesOnly && encoder) {
+      obj = maybe_map(obj, encoder);
+    }
+    obj_keys = [{ value: obj.length > 0 ? obj.join(",") || null : undefined }];
+  } else if (isArray(filter)) {
+    obj_keys = filter;
+  } else {
+    const keys = Object.keys(obj);
+    obj_keys = sort ? keys.sort(sort) : keys;
+  }
+  const encoded_prefix = encodeDotInKeys ? String(prefix).replace(/\./g, "%2E") : String(prefix);
+  const adjusted_prefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encoded_prefix + "[]" : encoded_prefix;
+  if (allowEmptyArrays && isArray(obj) && obj.length === 0) {
+    return adjusted_prefix + "[]";
+  }
+  for (let j = 0;j < obj_keys.length; ++j) {
+    const key = obj_keys[j];
+    const value = typeof key === "object" && typeof key.value !== "undefined" ? key.value : obj[key];
+    if (skipNulls && value === null) {
+      continue;
+    }
+    const encoded_key = allowDots && encodeDotInKeys ? key.replace(/\./g, "%2E") : key;
+    const key_prefix = isArray(obj) ? typeof generateArrayPrefix === "function" ? generateArrayPrefix(adjusted_prefix, encoded_key) : adjusted_prefix : adjusted_prefix + (allowDots ? "." + encoded_key : "[" + encoded_key + "]");
+    sideChannel.set(object, step);
+    const valueSideChannel = new WeakMap;
+    valueSideChannel.set(sentinel, sideChannel);
+    push_to_array(values, inner_stringify(value, key_prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, generateArrayPrefix === "comma" && encodeValuesOnly && isArray(obj) ? null : encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, valueSideChannel));
+  }
+  return values;
+}
+function normalize_stringify_options(opts = defaults) {
+  if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") {
+    throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided");
+  }
+  if (typeof opts.encodeDotInKeys !== "undefined" && typeof opts.encodeDotInKeys !== "boolean") {
+    throw new TypeError("`encodeDotInKeys` option can only be `true` or `false`, when provided");
+  }
+  if (opts.encoder !== null && typeof opts.encoder !== "undefined" && typeof opts.encoder !== "function") {
+    throw new TypeError("Encoder has to be a function.");
+  }
+  const charset = opts.charset || defaults.charset;
+  if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") {
+    throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
+  }
+  let format = default_format;
+  if (typeof opts.format !== "undefined") {
+    if (!has(formatters, opts.format)) {
+      throw new TypeError("Unknown format option provided.");
+    }
+    format = opts.format;
+  }
+  const formatter = formatters[format];
+  let filter = defaults.filter;
+  if (typeof opts.filter === "function" || isArray(opts.filter)) {
+    filter = opts.filter;
+  }
+  let arrayFormat;
+  if (opts.arrayFormat && opts.arrayFormat in array_prefix_generators) {
+    arrayFormat = opts.arrayFormat;
+  } else if ("indices" in opts) {
+    arrayFormat = opts.indices ? "indices" : "repeat";
+  } else {
+    arrayFormat = defaults.arrayFormat;
+  }
+  if ("commaRoundTrip" in opts && typeof opts.commaRoundTrip !== "boolean") {
+    throw new TypeError("`commaRoundTrip` must be a boolean, or absent");
+  }
+  const allowDots = typeof opts.allowDots === "undefined" ? !!opts.encodeDotInKeys === true ? true : defaults.allowDots : !!opts.allowDots;
+  return {
+    addQueryPrefix: typeof opts.addQueryPrefix === "boolean" ? opts.addQueryPrefix : defaults.addQueryPrefix,
+    allowDots,
+    allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,
+    arrayFormat,
+    charset,
+    charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults.charsetSentinel,
+    commaRoundTrip: !!opts.commaRoundTrip,
+    delimiter: typeof opts.delimiter === "undefined" ? defaults.delimiter : opts.delimiter,
+    encode: typeof opts.encode === "boolean" ? opts.encode : defaults.encode,
+    encodeDotInKeys: typeof opts.encodeDotInKeys === "boolean" ? opts.encodeDotInKeys : defaults.encodeDotInKeys,
+    encoder: typeof opts.encoder === "function" ? opts.encoder : defaults.encoder,
+    encodeValuesOnly: typeof opts.encodeValuesOnly === "boolean" ? opts.encodeValuesOnly : defaults.encodeValuesOnly,
+    filter,
+    format,
+    formatter,
+    serializeDate: typeof opts.serializeDate === "function" ? opts.serializeDate : defaults.serializeDate,
+    skipNulls: typeof opts.skipNulls === "boolean" ? opts.skipNulls : defaults.skipNulls,
+    sort: typeof opts.sort === "function" ? opts.sort : null,
+    strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling
+  };
+}
+function stringify(object, opts = {}) {
+  let obj = object;
+  const options = normalize_stringify_options(opts);
+  let obj_keys;
+  let filter;
+  if (typeof options.filter === "function") {
+    filter = options.filter;
+    obj = filter("", obj);
+  } else if (isArray(options.filter)) {
+    filter = options.filter;
+    obj_keys = filter;
+  }
+  const keys = [];
+  if (typeof obj !== "object" || obj === null) {
+    return "";
+  }
+  const generateArrayPrefix = array_prefix_generators[options.arrayFormat];
+  const commaRoundTrip = generateArrayPrefix === "comma" && options.commaRoundTrip;
+  if (!obj_keys) {
+    obj_keys = Object.keys(obj);
+  }
+  if (options.sort) {
+    obj_keys.sort(options.sort);
+  }
+  const sideChannel = new WeakMap;
+  for (let i = 0;i < obj_keys.length; ++i) {
+    const key = obj_keys[i];
+    if (options.skipNulls && obj[key] === null) {
+      continue;
+    }
+    push_to_array(keys, inner_stringify(obj[key], key, generateArrayPrefix, commaRoundTrip, options.allowEmptyArrays, options.strictNullHandling, options.skipNulls, options.encodeDotInKeys, options.encode ? options.encoder : null, options.filter, options.sort, options.allowDots, options.serializeDate, options.format, options.formatter, options.encodeValuesOnly, options.charset, sideChannel));
+  }
+  const joined = keys.join(options.delimiter);
+  let prefix = options.addQueryPrefix === true ? "?" : "";
+  if (options.charsetSentinel) {
+    if (options.charset === "iso-8859-1") {
+      prefix += "utf8=%26%2310003%3B&";
+    } else {
+      prefix += "utf8=%E2%9C%93&";
+    }
+  }
+  return joined.length > 0 ? prefix + joined : "";
+}
+
+// node_modules/@letta-ai/letta-client/internal/utils/query.mjs
+function stringifyQuery(query) {
+  return stringify(query, { allowDots: true, arrayFormat: "repeat" });
+}
+
+// node_modules/@letta-ai/letta-client/internal/utils/bytes.mjs
+function concatBytes(buffers) {
+  let length = 0;
+  for (const buffer of buffers) {
+    length += buffer.length;
+  }
+  const output = new Uint8Array(length);
+  let index = 0;
+  for (const buffer of buffers) {
+    output.set(buffer, index);
+    index += buffer.length;
+  }
+  return output;
+}
+var encodeUTF8_;
+function encodeUTF8(str) {
+  let encoder;
+  return (encodeUTF8_ ?? (encoder = new globalThis.TextEncoder, encodeUTF8_ = encoder.encode.bind(encoder)))(str);
+}
+var decodeUTF8_;
+function decodeUTF8(bytes) {
+  let decoder;
+  return (decodeUTF8_ ?? (decoder = new globalThis.TextDecoder, decodeUTF8_ = decoder.decode.bind(decoder)))(bytes);
+}
+
+// node_modules/@letta-ai/letta-client/internal/decoders/line.mjs
+var _LineDecoder_buffer;
+var _LineDecoder_carriageReturnIndex;
+
+class LineDecoder {
+  constructor() {
+    _LineDecoder_buffer.set(this, undefined);
+    _LineDecoder_carriageReturnIndex.set(this, undefined);
+    __classPrivateFieldSet(this, _LineDecoder_buffer, new Uint8Array, "f");
+    __classPrivateFieldSet(this, _LineDecoder_carriageReturnIndex, null, "f");
+  }
+  decode(chunk) {
+    if (chunk == null) {
+      return [];
+    }
+    const binaryChunk = chunk instanceof ArrayBuffer ? new Uint8Array(chunk) : typeof chunk === "string" ? encodeUTF8(chunk) : chunk;
+    __classPrivateFieldSet(this, _LineDecoder_buffer, concatBytes([__classPrivateFieldGet(this, _LineDecoder_buffer, "f"), binaryChunk]), "f");
+    const lines = [];
+    let patternIndex;
+    while ((patternIndex = findNewlineIndex(__classPrivateFieldGet(this, _LineDecoder_buffer, "f"), __classPrivateFieldGet(this, _LineDecoder_carriageReturnIndex, "f"))) != null) {
+      if (patternIndex.carriage && __classPrivateFieldGet(this, _LineDecoder_carriageReturnIndex, "f") == null) {
+        __classPrivateFieldSet(this, _LineDecoder_carriageReturnIndex, patternIndex.index, "f");
+        continue;
+      }
+      if (__classPrivateFieldGet(this, _LineDecoder_carriageReturnIndex, "f") != null && (patternIndex.index !== __classPrivateFieldGet(this, _LineDecoder_carriageReturnIndex, "f") + 1 || patternIndex.carriage)) {
+        lines.push(decodeUTF8(__classPrivateFieldGet(this, _LineDecoder_buffer, "f").subarray(0, __classPrivateFieldGet(this, _LineDecoder_carriageReturnIndex, "f") - 1)));
+        __classPrivateFieldSet(this, _LineDecoder_buffer, __classPrivateFieldGet(this, _LineDecoder_buffer, "f").subarray(__classPrivateFieldGet(this, _LineDecoder_carriageReturnIndex, "f")), "f");
+        __classPrivateFieldSet(this, _LineDecoder_carriageReturnIndex, null, "f");
+        continue;
+      }
+      const endIndex = __classPrivateFieldGet(this, _LineDecoder_carriageReturnIndex, "f") !== null ? patternIndex.preceding - 1 : patternIndex.preceding;
+      const line = decodeUTF8(__classPrivateFieldGet(this, _LineDecoder_buffer, "f").subarray(0, endIndex));
+      lines.push(line);
+      __classPrivateFieldSet(this, _LineDecoder_buffer, __classPrivateFieldGet(this, _LineDecoder_buffer, "f").subarray(patternIndex.index), "f");
+      __classPrivateFieldSet(this, _LineDecoder_carriageReturnIndex, null, "f");
+    }
+    return lines;
+  }
+  flush() {
+    if (!__classPrivateFieldGet(this, _LineDecoder_buffer, "f").length) {
+      return [];
+    }
+    return this.decode(`
+`);
+  }
+}
+_LineDecoder_buffer = new WeakMap, _LineDecoder_carriageReturnIndex = new WeakMap;
+LineDecoder.NEWLINE_CHARS = new Set([`
+`, "\r"]);
+LineDecoder.NEWLINE_REGEXP = /\r\n|[\n\r]/g;
+function findNewlineIndex(buffer, startIndex) {
+  const newline = 10;
+  const carriage = 13;
+  for (let i = startIndex ?? 0;i < buffer.length; i++) {
+    if (buffer[i] === newline) {
+      return { preceding: i, index: i + 1, carriage: false };
+    }
+    if (buffer[i] === carriage) {
+      return { preceding: i, index: i + 1, carriage: true };
+    }
+  }
+  return null;
+}
+function findDoubleNewlineIndex(buffer) {
+  const newline = 10;
+  const carriage = 13;
+  for (let i = 0;i < buffer.length - 1; i++) {
+    if (buffer[i] === newline && buffer[i + 1] === newline) {
+      return i + 2;
+    }
+    if (buffer[i] === carriage && buffer[i + 1] === carriage) {
+      return i + 2;
+    }
+    if (buffer[i] === carriage && buffer[i + 1] === newline && i + 3 < buffer.length && buffer[i + 2] === carriage && buffer[i + 3] === newline) {
+      return i + 4;
+    }
+  }
+  return -1;
+}
+
+// node_modules/@letta-ai/letta-client/internal/utils/log.mjs
+var levelNumbers = {
+  off: 0,
+  error: 200,
+  warn: 300,
+  info: 400,
+  debug: 500
+};
+var parseLogLevel = (maybeLevel, sourceName, client) => {
+  if (!maybeLevel) {
+    return;
+  }
+  if (hasOwn(levelNumbers, maybeLevel)) {
+    return maybeLevel;
+  }
+  loggerFor(client).warn(`${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify(Object.keys(levelNumbers))}`);
+  return;
+};
+function noop() {}
+function makeLogFn(fnLevel, logger, logLevel) {
+  if (!logger || levelNumbers[fnLevel] > levelNumbers[logLevel]) {
+    return noop;
+  } else {
+    return logger[fnLevel].bind(logger);
+  }
+}
+var noopLogger = {
+  error: noop,
+  warn: noop,
+  info: noop,
+  debug: noop
+};
+var cachedLoggers = /* @__PURE__ */ new WeakMap;
+function loggerFor(client) {
+  const logger = client.logger;
+  const logLevel = client.logLevel ?? "off";
+  if (!logger) {
+    return noopLogger;
+  }
+  const cachedLogger = cachedLoggers.get(logger);
+  if (cachedLogger && cachedLogger[0] === logLevel) {
+    return cachedLogger[1];
+  }
+  const levelLogger = {
+    error: makeLogFn("error", logger, logLevel),
+    warn: makeLogFn("warn", logger, logLevel),
+    info: makeLogFn("info", logger, logLevel),
+    debug: makeLogFn("debug", logger, logLevel)
+  };
+  cachedLoggers.set(logger, [logLevel, levelLogger]);
+  return levelLogger;
+}
+var formatRequestDetails = (details) => {
+  if (details.options) {
+    details.options = { ...details.options };
+    delete details.options["headers"];
   }
+  if (details.headers) {
+    details.headers = Object.fromEntries((details.headers instanceof Headers ? [...details.headers] : Object.entries(details.headers)).map(([name, value]) => [
+      name,
+      name.toLowerCase() === "authorization" || name.toLowerCase() === "api-key" || name.toLowerCase() === "x-api-key" || name.toLowerCase() === "cookie" || name.toLowerCase() === "set-cookie" ? "***" : value
+    ]));
+  }
+  if ("retryOfRequestLogID" in details) {
+    if (details.retryOfRequestLogID) {
+      details.retryOf = details.retryOfRequestLogID;
+    }
+    delete details.retryOfRequestLogID;
+  }
+  return details;
+};
+
+// node_modules/@letta-ai/letta-client/core/streaming.mjs
+var _Stream_client;
+
+class Stream {
+  constructor(iterator, controller, client) {
+    this.iterator = iterator;
+    _Stream_client.set(this, undefined);
+    this.controller = controller;
+    __classPrivateFieldSet(this, _Stream_client, client, "f");
+  }
+  static fromSSEResponse(response, controller, client) {
+    let consumed = false;
+    const logger = client ? loggerFor(client) : console;
+    async function* iterator() {
+      if (consumed) {
+        throw new LettaError("Cannot iterate over a consumed stream, use `.tee()` to split the stream.");
+      }
+      consumed = true;
+      let done = false;
+      try {
+        for await (const sse of _iterSSEMessages(response, controller)) {
+          if (done)
+            continue;
+          if (sse.data.startsWith("[DONE]")) {
+            done = true;
+            continue;
+          }
+          if (sse.event === "error") {
+            throw new APIError(undefined, safeJSON(sse.data) ?? sse.data, undefined, response.headers);
+          }
+          if (sse.event === null) {
+            try {
+              yield JSON.parse(sse.data);
+            } catch (e) {
+              logger.error(`Could not parse message into JSON:`, sse.data);
+              logger.error(`From chunk:`, sse.raw);
+              throw e;
+            }
+          }
+        }
+        done = true;
+      } catch (e) {
+        if (isAbortError(e))
+          return;
+        throw e;
+      } finally {
+        if (!done)
+          controller.abort();
+      }
+    }
+    return new Stream(iterator, controller, client);
+  }
+  static fromReadableStream(readableStream, controller, client) {
+    let consumed = false;
+    async function* iterLines() {
+      const lineDecoder = new LineDecoder;
+      const iter = ReadableStreamToAsyncIterable(readableStream);
+      for await (const chunk of iter) {
+        for (const line of lineDecoder.decode(chunk)) {
+          yield line;
+        }
+      }
+      for (const line of lineDecoder.flush()) {
+        yield line;
+      }
+    }
+    async function* iterator() {
+      if (consumed) {
+        throw new LettaError("Cannot iterate over a consumed stream, use `.tee()` to split the stream.");
+      }
+      consumed = true;
+      let done = false;
+      try {
+        for await (const line of iterLines()) {
+          if (done)
+            continue;
+          if (line)
+            yield JSON.parse(line);
+        }
+        done = true;
+      } catch (e) {
+        if (isAbortError(e))
+          return;
+        throw e;
+      } finally {
+        if (!done)
+          controller.abort();
+      }
+    }
+    return new Stream(iterator, controller, client);
+  }
+  [(_Stream_client = new WeakMap, Symbol.asyncIterator)]() {
+    return this.iterator();
+  }
+  tee() {
+    const left = [];
+    const right = [];
+    const iterator = this.iterator();
+    const teeIterator = (queue) => {
+      return {
+        next: () => {
+          if (queue.length === 0) {
+            const result = iterator.next();
+            left.push(result);
+            right.push(result);
+          }
+          return queue.shift();
+        }
+      };
+    };
+    return [
+      new Stream(() => teeIterator(left), this.controller, __classPrivateFieldGet(this, _Stream_client, "f")),
+      new Stream(() => teeIterator(right), this.controller, __classPrivateFieldGet(this, _Stream_client, "f"))
+    ];
+  }
+  toReadableStream() {
+    const self = this;
+    let iter;
+    return makeReadableStream({
+      async start() {
+        iter = self[Symbol.asyncIterator]();
+      },
+      async pull(ctrl) {
+        try {
+          const { value, done } = await iter.next();
+          if (done)
+            return ctrl.close();
+          const bytes = encodeUTF8(JSON.stringify(value) + `
+`);
+          ctrl.enqueue(bytes);
+        } catch (err) {
+          ctrl.error(err);
+        }
+      },
+      async cancel() {
+        await iter.return?.();
+      }
+    });
+  }
+}
+async function* _iterSSEMessages(response, controller) {
+  if (!response.body) {
+    controller.abort();
+    if (typeof globalThis.navigator !== "undefined" && globalThis.navigator.product === "ReactNative") {
+      throw new LettaError(`The default react-native fetch implementation does not support streaming. Please use expo/fetch: https://docs.expo.dev/versions/latest/sdk/expo/#expofetch-api`);
+    }
+    throw new LettaError(`Attempted to iterate over a response with no body`);
+  }
+  const sseDecoder = new SSEDecoder;
+  const lineDecoder = new LineDecoder;
+  const iter = ReadableStreamToAsyncIterable(response.body);
+  for await (const sseChunk of iterSSEChunks(iter)) {
+    for (const line of lineDecoder.decode(sseChunk)) {
+      const sse = sseDecoder.decode(line);
+      if (sse)
+        yield sse;
+    }
+  }
+  for (const line of lineDecoder.flush()) {
+    const sse = sseDecoder.decode(line);
+    if (sse)
+      yield sse;
+  }
+}
+async function* iterSSEChunks(iterator) {
+  let data = new Uint8Array;
+  for await (const chunk of iterator) {
+    if (chunk == null) {
+      continue;
+    }
+    const binaryChunk = chunk instanceof ArrayBuffer ? new Uint8Array(chunk) : typeof chunk === "string" ? encodeUTF8(chunk) : chunk;
+    let newData = new Uint8Array(data.length + binaryChunk.length);
+    newData.set(data);
+    newData.set(binaryChunk, data.length);
+    data = newData;
+    let patternIndex;
+    while ((patternIndex = findDoubleNewlineIndex(data)) !== -1) {
+      yield data.slice(0, patternIndex);
+      data = data.slice(patternIndex);
+    }
+  }
+  if (data.length > 0) {
+    yield data;
+  }
+}
+
+class SSEDecoder {
+  constructor() {
+    this.event = null;
+    this.data = [];
+    this.chunks = [];
+  }
+  decode(line) {
+    if (line.endsWith("\r")) {
+      line = line.substring(0, line.length - 1);
+    }
+    if (!line) {
+      if (!this.event && !this.data.length)
+        return null;
+      const sse = {
+        event: this.event,
+        data: this.data.join(`
+`),
+        raw: this.chunks
+      };
+      this.event = null;
+      this.data = [];
+      this.chunks = [];
+      return sse;
+    }
+    this.chunks.push(line);
+    if (line.startsWith(":")) {
+      return null;
+    }
+    let [fieldname, _, value] = partition(line, ":");
+    if (value.startsWith(" ")) {
+      value = value.substring(1);
+    }
+    if (fieldname === "event") {
+      this.event = value;
+    } else if (fieldname === "data") {
+      this.data.push(value);
+    }
+    return null;
+  }
+}
+function partition(str, delimiter) {
+  const index = str.indexOf(delimiter);
+  if (index !== -1) {
+    return [str.substring(0, index), delimiter, str.substring(index + delimiter.length)];
+  }
+  return [str, "", ""];
+}
+
+// node_modules/@letta-ai/letta-client/internal/parse.mjs
+async function defaultParseResponse(client, props) {
+  const { response, requestLogID, retryOfRequestLogID, startTime } = props;
+  const body = await (async () => {
+    if (props.options.stream) {
+      loggerFor(client).debug("response", response.status, response.url, response.headers, response.body);
+      if (props.options.__streamClass) {
+        return props.options.__streamClass.fromSSEResponse(response, props.controller, client);
+      }
+      return Stream.fromSSEResponse(response, props.controller, client);
+    }
+    if (response.status === 204) {
+      return null;
+    }
+    if (props.options.__binaryResponse) {
+      return response;
+    }
+    const contentType = response.headers.get("content-type");
+    const mediaType = contentType?.split(";")[0]?.trim();
+    const isJSON = mediaType?.includes("application/json") || mediaType?.endsWith("+json");
+    if (isJSON) {
+      const contentLength = response.headers.get("content-length");
+      if (contentLength === "0") {
+        return;
+      }
+      const json = await response.json();
+      return json;
+    }
+    const text = await response.text();
+    return text;
+  })();
+  loggerFor(client).debug(`[${requestLogID}] response parsed`, formatRequestDetails({
+    retryOfRequestLogID,
+    url: response.url,
+    status: response.status,
+    body,
+    durationMs: Date.now() - startTime
+  }));
+  return body;
+}
+
+// node_modules/@letta-ai/letta-client/core/api-promise.mjs
+var _APIPromise_client;
+
+class APIPromise extends Promise {
+  constructor(client, responsePromise, parseResponse = defaultParseResponse) {
+    super((resolve) => {
+      resolve(null);
+    });
+    this.responsePromise = responsePromise;
+    this.parseResponse = parseResponse;
+    _APIPromise_client.set(this, undefined);
+    __classPrivateFieldSet(this, _APIPromise_client, client, "f");
+  }
+  _thenUnwrap(transform) {
+    return new APIPromise(__classPrivateFieldGet(this, _APIPromise_client, "f"), this.responsePromise, async (client, props) => transform(await this.parseResponse(client, props), props));
+  }
+  asResponse() {
+    return this.responsePromise.then((p) => p.response);
+  }
+  async withResponse() {
+    const [data, response] = await Promise.all([this.parse(), this.asResponse()]);
+    return { data, response };
+  }
+  parse() {
+    if (!this.parsedPromise) {
+      this.parsedPromise = this.responsePromise.then((data) => this.parseResponse(__classPrivateFieldGet(this, _APIPromise_client, "f"), data));
+    }
+    return this.parsedPromise;
+  }
+  then(onfulfilled, onrejected) {
+    return this.parse().then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.parse().catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.parse().finally(onfinally);
+  }
+}
+_APIPromise_client = new WeakMap;
+
+// node_modules/@letta-ai/letta-client/core/pagination.mjs
+var _AbstractPage_client;
+
+class AbstractPage {
+  constructor(client, response, body, options) {
+    _AbstractPage_client.set(this, undefined);
+    __classPrivateFieldSet(this, _AbstractPage_client, client, "f");
+    this.options = options;
+    this.response = response;
+    this.body = body;
+  }
+  hasNextPage() {
+    const items = this.getPaginatedItems();
+    if (!items.length)
+      return false;
+    return this.nextPageRequestOptions() != null;
+  }
+  async getNextPage() {
+    const nextOptions = this.nextPageRequestOptions();
+    if (!nextOptions) {
+      throw new LettaError("No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`.");
+    }
+    return await __classPrivateFieldGet(this, _AbstractPage_client, "f").requestAPIList(this.constructor, nextOptions);
+  }
+  async* iterPages() {
+    let page = this;
+    yield page;
+    while (page.hasNextPage()) {
+      page = await page.getNextPage();
+      yield page;
+    }
+  }
+  async* [(_AbstractPage_client = new WeakMap, Symbol.asyncIterator)]() {
+    for await (const page of this.iterPages()) {
+      for (const item of page.getPaginatedItems()) {
+        yield item;
+      }
+    }
+  }
+}
+
+class PagePromise extends APIPromise {
+  constructor(client, request, Page) {
+    super(client, request, async (client2, props) => new Page(client2, props.response, await defaultParseResponse(client2, props), props.options));
+  }
+  async* [Symbol.asyncIterator]() {
+    const page = await this;
+    for await (const item of page) {
+      yield item;
+    }
+  }
+}
+
+class ArrayPage extends AbstractPage {
+  constructor(client, response, body, options) {
+    super(client, response, body, options);
+    this.items = body || [];
+  }
+  getPaginatedItems() {
+    return this.items ?? [];
+  }
+  nextPageRequestOptions() {
+    const items = this.getPaginatedItems();
+    const isForwards = !(typeof this.options.query === "object" && ("before" in (this.options.query || {})));
+    if (isForwards) {
+      const id2 = items[items.length - 1]?.id;
+      if (!id2) {
+        return null;
+      }
+      return {
+        ...this.options,
+        query: {
+          ...maybeObj(this.options.query),
+          after: id2
+        }
+      };
+    }
+    const id = items[0]?.id;
+    if (!id) {
+      return null;
+    }
+    return {
+      ...this.options,
+      query: {
+        ...maybeObj(this.options.query),
+        before: id
+      }
+    };
+  }
+}
+class NextFilesPage extends AbstractPage {
+  constructor(client, response, body, options) {
+    super(client, response, body, options);
+    this.files = body.files || [];
+    this.next_cursor = body.next_cursor || null;
+    this.has_more = body.has_more || false;
+  }
+  getPaginatedItems() {
+    return this.files ?? [];
+  }
+  hasNextPage() {
+    if (this.has_more === false) {
+      return false;
+    }
+    return super.hasNextPage();
+  }
+  nextPageRequestOptions() {
+    const files = this.getPaginatedItems();
+    const isForwards = !(typeof this.options.query === "object" && ("before" in (this.options.query || {})));
+    if (isForwards) {
+      const id2 = files[files.length - 1]?.id;
+      if (!id2) {
+        return null;
+      }
+      return {
+        ...this.options,
+        query: {
+          ...maybeObj(this.options.query),
+          after: id2
+        }
+      };
+    }
+    const id = files[0]?.id;
+    if (!id) {
+      return null;
+    }
+    return {
+      ...this.options,
+      query: {
+        ...maybeObj(this.options.query),
+        before: id
+      }
+    };
+  }
+}
+
+// node_modules/@letta-ai/letta-client/internal/uploads.mjs
+var checkFileSupport = () => {
+  if (typeof File === "undefined") {
+    const { process } = globalThis;
+    const isOldNode = typeof process?.versions?.node === "string" && parseInt(process.versions.node.split(".")) < 20;
+    throw new Error("`File` is not defined as a global, which is required for file uploads." + (isOldNode ? " Update to Node 20 LTS or newer, or set `globalThis.File` to `import('node:buffer').File`." : ""));
+  }
+};
+function makeFile(fileBits, fileName, options) {
+  checkFileSupport();
+  return new File(fileBits, fileName ?? "unknown_file", options);
+}
+function getName(value) {
+  return (typeof value === "object" && value !== null && (("name" in value) && value.name && String(value.name) || ("url" in value) && value.url && String(value.url) || ("filename" in value) && value.filename && String(value.filename) || ("path" in value) && value.path && String(value.path)) || "").split(/[\\/]/).pop() || undefined;
+}
+var isAsyncIterable = (value) => value != null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function";
+var multipartFormRequestOptions = async (opts, fetch2) => {
+  return { ...opts, body: await createForm(opts.body, fetch2) };
+};
+var supportsFormDataMap = /* @__PURE__ */ new WeakMap;
+function supportsFormData(fetchObject) {
+  const fetch2 = typeof fetchObject === "function" ? fetchObject : fetchObject.fetch;
+  const cached = supportsFormDataMap.get(fetch2);
+  if (cached)
+    return cached;
+  const promise = (async () => {
+    try {
+      const FetchResponse = "Response" in fetch2 ? fetch2.Response : (await fetch2("data:,")).constructor;
+      const data = new FormData;
+      if (data.toString() === await new FetchResponse(data).text()) {
+        return false;
+      }
+      return true;
+    } catch {
+      return true;
+    }
+  })();
+  supportsFormDataMap.set(fetch2, promise);
+  return promise;
+}
+var createForm = async (body, fetch2) => {
+  if (!await supportsFormData(fetch2)) {
+    throw new TypeError("The provided fetch function does not support file uploads with the current global FormData class.");
+  }
+  const form = new FormData;
+  await Promise.all(Object.entries(body || {}).map(([key, value]) => addFormValue(form, key, value)));
+  return form;
+};
+var isNamedBlob = (value) => value instanceof Blob && ("name" in value);
+var addFormValue = async (form, key, value) => {
+  if (value === undefined)
+    return;
+  if (value == null) {
+    throw new TypeError(`Received null for "${key}"; to pass null in FormData, you must use the string 'null'`);
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    form.append(key, String(value));
+  } else if (value instanceof Response) {
+    form.append(key, makeFile([await value.blob()], getName(value)));
+  } else if (isAsyncIterable(value)) {
+    form.append(key, makeFile([await new Response(ReadableStreamFrom(value)).blob()], getName(value)));
+  } else if (isNamedBlob(value)) {
+    form.append(key, value, getName(value));
+  } else if (Array.isArray(value)) {
+    await Promise.all(value.map((entry) => addFormValue(form, key + "[]", entry)));
+  } else if (typeof value === "object") {
+    await Promise.all(Object.entries(value).map(([name, prop]) => addFormValue(form, `${key}[${name}]`, prop)));
+  } else {
+    throw new TypeError(`Invalid value given to form, expected a string, number, boolean, object, Array, File or Blob but got ${value} instead`);
+  }
+};
+
+// node_modules/@letta-ai/letta-client/internal/to-file.mjs
+var isBlobLike = (value) => value != null && typeof value === "object" && typeof value.size === "number" && typeof value.type === "string" && typeof value.text === "function" && typeof value.slice === "function" && typeof value.arrayBuffer === "function";
+var isFileLike = (value) => value != null && typeof value === "object" && typeof value.name === "string" && typeof value.lastModified === "number" && isBlobLike(value);
+var isResponseLike = (value) => value != null && typeof value === "object" && typeof value.url === "string" && typeof value.blob === "function";
+async function toFile(value, name, options) {
+  checkFileSupport();
+  value = await value;
+  if (isFileLike(value)) {
+    if (value instanceof File) {
+      return value;
+    }
+    return makeFile([await value.arrayBuffer()], value.name);
+  }
+  if (isResponseLike(value)) {
+    const blob = await value.blob();
+    name || (name = new URL(value.url).pathname.split(/[\\/]/).pop());
+    return makeFile(await getBytes(blob), name, options);
+  }
+  const parts = await getBytes(value);
+  name || (name = getName(value));
+  if (!options?.type) {
+    const type = parts.find((part) => typeof part === "object" && ("type" in part) && part.type);
+    if (typeof type === "string") {
+      options = { ...options, type };
+    }
+  }
+  return makeFile(parts, name, options);
+}
+async function getBytes(value) {
+  let parts = [];
+  if (typeof value === "string" || ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
+    parts.push(value);
+  } else if (isBlobLike(value)) {
+    parts.push(value instanceof Blob ? value : await value.arrayBuffer());
+  } else if (isAsyncIterable(value)) {
+    for await (const chunk of value) {
+      parts.push(...await getBytes(chunk));
+    }
+  } else {
+    const constructor = value?.constructor?.name;
+    throw new Error(`Unexpected data type: ${typeof value}${constructor ? `; constructor: ${constructor}` : ""}${propsForError(value)}`);
+  }
+  return parts;
+}
+function propsForError(value) {
+  if (typeof value !== "object" || value === null)
+    return "";
+  const props = Object.getOwnPropertyNames(value);
+  return `; props: [${props.map((p) => `"${p}"`).join(", ")}]`;
+}
+// node_modules/@letta-ai/letta-client/core/resource.mjs
+class APIResource {
+  constructor(client) {
+    this._client = client;
+  }
+}
+
+// node_modules/@letta-ai/letta-client/internal/utils/path.mjs
+function encodeURIPath(str) {
+  return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent);
+}
+var EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null));
+var createPathTagFunction = (pathEncoder = encodeURIPath) => function path(statics, ...params) {
+  if (statics.length === 1)
+    return statics[0];
+  let postPath = false;
+  const invalidSegments = [];
+  const path = statics.reduce((previousValue, currentValue, index) => {
+    if (/[?#]/.test(currentValue)) {
+      postPath = true;
+    }
+    const value = params[index];
+    let encoded = (postPath ? encodeURIComponent : pathEncoder)("" + value);
+    if (index !== params.length && (value == null || typeof value === "object" && value.toString === Object.getPrototypeOf(Object.getPrototypeOf(value.hasOwnProperty ?? EMPTY) ?? EMPTY)?.toString)) {
+      encoded = value + "";
+      invalidSegments.push({
+        start: previousValue.length + currentValue.length,
+        length: encoded.length,
+        error: `Value of type ${Object.prototype.toString.call(value).slice(8, -1)} is not a valid path parameter`
+      });
+    }
+    return previousValue + currentValue + (index === params.length ? "" : encoded);
+  }, "");
+  const pathOnly = path.split(/[?#]/, 1)[0];
+  const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
+  let match;
+  while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) {
+    invalidSegments.push({
+      start: match.index,
+      length: match[0].length,
+      error: `Value "${match[0]}" can't be safely passed as a path parameter`
+    });
+  }
+  invalidSegments.sort((a, b) => a.start - b.start);
+  if (invalidSegments.length > 0) {
+    let lastEnd = 0;
+    const underline = invalidSegments.reduce((acc, segment) => {
+      const spaces = " ".repeat(segment.start - lastEnd);
+      const arrows = "^".repeat(segment.length);
+      lastEnd = segment.start + segment.length;
+      return acc + spaces + arrows;
+    }, "");
+    throw new LettaError(`Path parameters result in path with invalid segments:
+${invalidSegments.map((e) => e.error).join(`
+`)}
+${path}
+${underline}`);
+  }
+  return path;
+};
+var path = /* @__PURE__ */ createPathTagFunction(encodeURIPath);
+
+// node_modules/@letta-ai/letta-client/resources/access-tokens.mjs
+class AccessTokens extends APIResource {
+  create(body, options) {
+    return this._client.post("/v1/client-side-access-tokens", { body, ...options });
+  }
+  list(query = {}, options) {
+    return this._client.get("/v1/client-side-access-tokens", { query, ...options });
+  }
+  delete(token, params = undefined, options) {
+    const { body } = params ?? {};
+    return this._client.delete(path`/v1/client-side-access-tokens/${token}`, { body, ...options });
+  }
+}
+// node_modules/@letta-ai/letta-client/resources/agents/archives.mjs
+class Archives extends APIResource {
+  attach(archiveID, params, options) {
+    const { agent_id } = params;
+    return this._client.patch(path`/v1/agents/${agent_id}/archives/attach/${archiveID}`, options);
+  }
+  detach(archiveID, params, options) {
+    const { agent_id } = params;
+    return this._client.patch(path`/v1/agents/${agent_id}/archives/detach/${archiveID}`, options);
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/agents/blocks.mjs
+class Blocks extends APIResource {
+  retrieve(blockLabel, params, options) {
+    const { agent_id } = params;
+    return this._client.get(path`/v1/agents/${agent_id}/core-memory/blocks/${blockLabel}`, options);
+  }
+  update(blockLabel, params, options) {
+    const { agent_id, ...body } = params;
+    return this._client.patch(path`/v1/agents/${agent_id}/core-memory/blocks/${blockLabel}`, {
+      body,
+      ...options
+    });
+  }
+  list(agentID, query = {}, options) {
+    return this._client.getAPIList(path`/v1/agents/${agentID}/core-memory/blocks`, ArrayPage, { query, ...options });
+  }
+  attach(blockID, params, options) {
+    const { agent_id } = params;
+    return this._client.patch(path`/v1/agents/${agent_id}/core-memory/blocks/attach/${blockID}`, options);
+  }
+  detach(blockID, params, options) {
+    const { agent_id } = params;
+    return this._client.patch(path`/v1/agents/${agent_id}/core-memory/blocks/detach/${blockID}`, options);
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/agents/files.mjs
+class Files extends APIResource {
+  list(agentID, query = {}, options) {
+    return this._client.getAPIList(path`/v1/agents/${agentID}/files`, NextFilesPage, {
+      query,
+      ...options
+    });
+  }
+  close(fileID, params, options) {
+    const { agent_id } = params;
+    return this._client.patch(path`/v1/agents/${agent_id}/files/${fileID}/close`, options);
+  }
+  closeAll(agentID, options) {
+    return this._client.patch(path`/v1/agents/${agentID}/files/close-all`, options);
+  }
+  open(fileID, params, options) {
+    const { agent_id } = params;
+    return this._client.patch(path`/v1/agents/${agent_id}/files/${fileID}/open`, options);
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/agents/folders.mjs
+class Folders extends APIResource {
+  list(agentID, query = {}, options) {
+    return this._client.getAPIList(path`/v1/agents/${agentID}/folders`, ArrayPage, {
+      query,
+      ...options
+    });
+  }
+  attach(folderID, params, options) {
+    const { agent_id } = params;
+    return this._client.patch(path`/v1/agents/${agent_id}/folders/attach/${folderID}`, options);
+  }
+  detach(folderID, params, options) {
+    const { agent_id } = params;
+    return this._client.patch(path`/v1/agents/${agent_id}/folders/detach/${folderID}`, options);
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/agents/identities.mjs
+class Identities extends APIResource {
+  attach(identityID, params, options) {
+    const { agent_id } = params;
+    return this._client.patch(path`/v1/agents/${agent_id}/identities/attach/${identityID}`, options);
+  }
+  detach(identityID, params, options) {
+    const { agent_id } = params;
+    return this._client.patch(path`/v1/agents/${agent_id}/identities/detach/${identityID}`, options);
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/agents/messages.mjs
+class Messages extends APIResource {
+  create(agentID, body, options) {
+    return this._client.post(path`/v1/agents/${agentID}/messages`, {
+      body,
+      ...options,
+      stream: body.streaming ?? false
+    });
+  }
+  list(agentID, query = {}, options) {
+    return this._client.getAPIList(path`/v1/agents/${agentID}/messages`, ArrayPage, {
+      query,
+      ...options
+    });
+  }
+  cancel(agentID, body = {}, options) {
+    return this._client.post(path`/v1/agents/${agentID}/messages/cancel`, { body, ...options });
+  }
+  compact(agentID, body = {}, options) {
+    return this._client.post(path`/v1/agents/${agentID}/summarize`, { body, ...options });
+  }
+  createAsync(agentID, body, options) {
+    return this._client.post(path`/v1/agents/${agentID}/messages/async`, { body, ...options });
+  }
+  reset(agentID, body, options) {
+    return this._client.patch(path`/v1/agents/${agentID}/reset-messages`, { body, ...options });
+  }
+  stream(agentID, body, options) {
+    return this._client.post(path`/v1/agents/${agentID}/messages/stream`, {
+      body,
+      ...options,
+      stream: true
+    });
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/agents/passages.mjs
+class Passages extends APIResource {
+  create(agentID, body, options) {
+    return this._client.post(path`/v1/agents/${agentID}/archival-memory`, { body, ...options });
+  }
+  list(agentID, query = {}, options) {
+    return this._client.get(path`/v1/agents/${agentID}/archival-memory`, { query, ...options });
+  }
+  delete(memoryID, params, options) {
+    const { agent_id } = params;
+    return this._client.delete(path`/v1/agents/${agent_id}/archival-memory/${memoryID}`, options);
+  }
+  search(agentID, query, options) {
+    return this._client.get(path`/v1/agents/${agentID}/archival-memory/search`, { query, ...options });
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/agents/schedule.mjs
+class Schedule extends APIResource {
+  create(agentID, body, options) {
+    return this._client.post(path`/v1/agents/${agentID}/schedule`, { body, ...options });
+  }
+  retrieve(scheduledMessageID, params, options) {
+    const { agent_id } = params;
+    return this._client.get(path`/v1/agents/${agent_id}/schedule/${scheduledMessageID}`, options);
+  }
+  list(agentID, query = {}, options) {
+    return this._client.get(path`/v1/agents/${agentID}/schedule`, { query, ...options });
+  }
+  delete(scheduledMessageID, params, options) {
+    const { agent_id, ...body } = params;
+    return this._client.delete(path`/v1/agents/${agent_id}/schedule/${scheduledMessageID}`, {
+      body,
+      ...options
+    });
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/agents/tools.mjs
+class Tools extends APIResource {
+  list(agentID, query = {}, options) {
+    return this._client.getAPIList(path`/v1/agents/${agentID}/tools`, ArrayPage, {
+      query,
+      ...options
+    });
+  }
+  attach(toolID, params, options) {
+    const { agent_id } = params;
+    return this._client.patch(path`/v1/agents/${agent_id}/tools/attach/${toolID}`, options);
+  }
+  detach(toolID, params, options) {
+    const { agent_id } = params;
+    return this._client.patch(path`/v1/agents/${agent_id}/tools/detach/${toolID}`, options);
+  }
+  run(toolName, params, options) {
+    const { agent_id, ...body } = params;
+    return this._client.post(path`/v1/agents/${agent_id}/tools/${toolName}/run`, { body, ...options });
+  }
+  updateApproval(toolName, params, options) {
+    const { agent_id, query_requires_approval, ...body } = params;
+    return this._client.patch(path`/v1/agents/${agent_id}/tools/approval/${toolName}`, {
+      query: { requires_approval: query_requires_approval },
+      body,
+      ...options
+    });
+  }
+}
+
+// node_modules/@letta-ai/letta-client/internal/headers.mjs
+var brand_privateNullableHeaders = /* @__PURE__ */ Symbol("brand.privateNullableHeaders");
+function* iterateHeaders(headers) {
+  if (!headers)
+    return;
+  if (brand_privateNullableHeaders in headers) {
+    const { values, nulls } = headers;
+    yield* values.entries();
+    for (const name of nulls) {
+      yield [name, null];
+    }
+    return;
+  }
+  let shouldClear = false;
+  let iter;
+  if (headers instanceof Headers) {
+    iter = headers.entries();
+  } else if (isReadonlyArray(headers)) {
+    iter = headers;
+  } else {
+    shouldClear = true;
+    iter = Object.entries(headers ?? {});
+  }
+  for (let row of iter) {
+    const name = row[0];
+    if (typeof name !== "string")
+      throw new TypeError("expected header name to be a string");
+    const values = isReadonlyArray(row[1]) ? row[1] : [row[1]];
+    let didClear = false;
+    for (const value of values) {
+      if (value === undefined)
+        continue;
+      if (shouldClear && !didClear) {
+        didClear = true;
+        yield [name, null];
+      }
+      yield [name, value];
+    }
+  }
+}
+var buildHeaders = (newHeaders) => {
+  const targetHeaders = new Headers;
+  const nullHeaders = new Set;
+  for (const headers of newHeaders) {
+    const seenHeaders = new Set;
+    for (const [name, value] of iterateHeaders(headers)) {
+      const lowerName = name.toLowerCase();
+      if (!seenHeaders.has(lowerName)) {
+        targetHeaders.delete(name);
+        seenHeaders.add(lowerName);
+      }
+      if (value === null) {
+        targetHeaders.delete(name);
+        nullHeaders.add(lowerName);
+      } else {
+        targetHeaders.append(name, value);
+        nullHeaders.delete(lowerName);
+      }
+    }
+  }
+  return { [brand_privateNullableHeaders]: true, values: targetHeaders, nulls: nullHeaders };
+};
+
+// node_modules/@letta-ai/letta-client/resources/agents/agents.mjs
+class Agents extends APIResource {
+  constructor() {
+    super(...arguments);
+    this.messages = new Messages(this._client);
+    this.schedule = new Schedule(this._client);
+    this.blocks = new Blocks(this._client);
+    this.tools = new Tools(this._client);
+    this.folders = new Folders(this._client);
+    this.files = new Files(this._client);
+    this.archives = new Archives(this._client);
+    this.passages = new Passages(this._client);
+    this.identities = new Identities(this._client);
+  }
+  create(body, options) {
+    return this._client.post("/v1/agents/", { body, ...options });
+  }
+  retrieve(agentID, query = {}, options) {
+    return this._client.get(path`/v1/agents/${agentID}`, { query, ...options });
+  }
+  update(agentID, body, options) {
+    return this._client.patch(path`/v1/agents/${agentID}`, { body, ...options });
+  }
+  list(query = {}, options) {
+    return this._client.getAPIList("/v1/agents/", ArrayPage, { query, ...options });
+  }
+  delete(agentID, options) {
+    return this._client.delete(path`/v1/agents/${agentID}`, options);
+  }
+  exportFile(agentID, query = {}, options) {
+    return this._client.get(path`/v1/agents/${agentID}/export`, { query, ...options });
+  }
+  importFile(params, options) {
+    const { "x-override-embedding-model": xOverrideEmbeddingModel, ...body } = params;
+    return this._client.post("/v1/agents/import", multipartFormRequestOptions({
+      body,
+      ...options,
+      headers: buildHeaders([
+        {
+          ...xOverrideEmbeddingModel != null ? { "x-override-embedding-model": xOverrideEmbeddingModel } : undefined
+        },
+        options?.headers
+      ])
+    }, this._client));
+  }
+  recompile(agentID, params = {}, options) {
+    const { dry_run, update_timestamp } = params ?? {};
+    return this._client.post(path`/v1/agents/${agentID}/recompile`, {
+      query: { dry_run, update_timestamp },
+      ...options
+    });
+  }
+}
+Agents.Messages = Messages;
+Agents.Schedule = Schedule;
+Agents.Blocks = Blocks;
+Agents.Tools = Tools;
+Agents.Folders = Folders;
+Agents.Files = Files;
+Agents.Archives = Archives;
+Agents.Passages = Passages;
+Agents.Identities = Identities;
+// node_modules/@letta-ai/letta-client/resources/archives/passages.mjs
+class Passages2 extends APIResource {
+  create(archiveID, body, options) {
+    return this._client.post(path`/v1/archives/${archiveID}/passages`, { body, ...options });
+  }
+  delete(passageID, params, options) {
+    const { archive_id } = params;
+    return this._client.delete(path`/v1/archives/${archive_id}/passages/${passageID}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: "*/*" }, options?.headers])
+    });
+  }
+  createMany(archiveID, body, options) {
+    return this._client.post(path`/v1/archives/${archiveID}/passages/batch`, { body, ...options });
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/archives/archives.mjs
+class Archives2 extends APIResource {
+  constructor() {
+    super(...arguments);
+    this.passages = new Passages2(this._client);
+  }
+  create(body, options) {
+    return this._client.post("/v1/archives/", { body, ...options });
+  }
+  retrieve(archiveID, options) {
+    return this._client.get(path`/v1/archives/${archiveID}`, options);
+  }
+  update(archiveID, body, options) {
+    return this._client.patch(path`/v1/archives/${archiveID}`, { body, ...options });
+  }
+  list(query = {}, options) {
+    return this._client.getAPIList("/v1/archives/", ArrayPage, { query, ...options });
+  }
+  delete(archiveID, options) {
+    return this._client.delete(path`/v1/archives/${archiveID}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: "*/*" }, options?.headers])
+    });
+  }
+}
+Archives2.Passages = Passages2;
+// node_modules/@letta-ai/letta-client/resources/blocks/agents.mjs
+class Agents2 extends APIResource {
+  list(blockID, query = {}, options) {
+    return this._client.getAPIList(path`/v1/blocks/${blockID}/agents`, ArrayPage, {
+      query,
+      ...options
+    });
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/blocks/blocks.mjs
+class Blocks2 extends APIResource {
+  constructor() {
+    super(...arguments);
+    this.agents = new Agents2(this._client);
+  }
+  create(body, options) {
+    return this._client.post("/v1/blocks/", { body, ...options });
+  }
+  retrieve(blockID, options) {
+    return this._client.get(path`/v1/blocks/${blockID}`, options);
+  }
+  update(blockID, body, options) {
+    return this._client.patch(path`/v1/blocks/${blockID}`, { body, ...options });
+  }
+  list(query = {}, options) {
+    return this._client.getAPIList("/v1/blocks/", ArrayPage, { query, ...options });
+  }
+  delete(blockID, options) {
+    return this._client.delete(path`/v1/blocks/${blockID}`, options);
+  }
+}
+Blocks2.Agents = Agents2;
+// node_modules/@letta-ai/letta-client/resources/conversations/messages.mjs
+class Messages2 extends APIResource {
+  create(conversationID, body, options) {
+    return this._client.post(path`/v1/conversations/${conversationID}/messages`, {
+      body,
+      ...options,
+      stream: true
+    });
+  }
+  list(conversationID, query = {}, options) {
+    return this._client.getAPIList(path`/v1/conversations/${conversationID}/messages`, ArrayPage, { query, ...options });
+  }
+  compact(conversationID, body = {}, options) {
+    return this._client.post(path`/v1/conversations/${conversationID}/compact`, { body, ...options });
+  }
+  stream(conversationID, body = {}, options) {
+    return this._client.post(path`/v1/conversations/${conversationID}/stream`, {
+      body,
+      ...options,
+      stream: true
+    });
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/conversations/conversations.mjs
+class Conversations extends APIResource {
+  constructor() {
+    super(...arguments);
+    this.messages = new Messages2(this._client);
+  }
+  create(params, options) {
+    const { agent_id, ...body } = params;
+    return this._client.post("/v1/conversations/", { query: { agent_id }, body, ...options });
+  }
+  retrieve(conversationID, options) {
+    return this._client.get(path`/v1/conversations/${conversationID}`, options);
+  }
+  update(conversationID, body, options) {
+    return this._client.patch(path`/v1/conversations/${conversationID}`, { body, ...options });
+  }
+  list(query = {}, options) {
+    return this._client.get("/v1/conversations/", { query, ...options });
+  }
+  delete(conversationID, options) {
+    return this._client.delete(path`/v1/conversations/${conversationID}`, options);
+  }
+  cancel(conversationID, params = {}, options) {
+    const { agent_id } = params ?? {};
+    return this._client.post(path`/v1/conversations/${conversationID}/cancel`, {
+      query: { agent_id },
+      ...options
+    });
+  }
+  fork(conversationID, params = {}, options) {
+    const { agent_id, hidden, message_id } = params ?? {};
+    return this._client.post(path`/v1/conversations/${conversationID}/fork`, {
+      query: { agent_id, hidden, message_id },
+      ...options
+    });
+  }
+  recompile(conversationID, params = {}, options) {
+    const { dry_run, ...body } = params ?? {};
+    return this._client.post(path`/v1/conversations/${conversationID}/recompile`, {
+      query: { dry_run },
+      body,
+      ...options
+    });
+  }
+}
+Conversations.Messages = Messages2;
+// node_modules/@letta-ai/letta-client/resources/environments.mjs
+class Environments extends APIResource {
+  retrieve(deviceID, options) {
+    return this._client.get(path`/v1/environments/${deviceID}`, options);
+  }
+  list(query = {}, options) {
+    return this._client.get("/v1/environments", { query, ...options });
+  }
+  sendMessage(connectionID, body, options) {
+    return this._client.post(path`/v1/environments/${connectionID}/messages`, { body, ...options });
+  }
+}
+// node_modules/@letta-ai/letta-client/resources/folders/agents.mjs
+class Agents3 extends APIResource {
+  list(folderID, query = {}, options) {
+    return this._client.get(path`/v1/folders/${folderID}/agents`, { query, ...options });
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/folders/files.mjs
+class Files2 extends APIResource {
+  retrieve(fileID, params, options) {
+    const { folder_id, ...query } = params;
+    return this._client.get(path`/v1/folders/${folder_id}/files/${fileID}`, { query, ...options });
+  }
+  list(folderID, query = {}, options) {
+    return this._client.getAPIList(path`/v1/folders/${folderID}/files`, ArrayPage, {
+      query,
+      ...options
+    });
+  }
+  delete(fileID, params, options) {
+    const { folder_id } = params;
+    return this._client.delete(path`/v1/folders/${folder_id}/${fileID}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: "*/*" }, options?.headers])
+    });
+  }
+  upload(folderID, params, options) {
+    const { duplicate_handling, name, ...body } = params;
+    return this._client.post(path`/v1/folders/${folderID}/upload`, multipartFormRequestOptions({ query: { duplicate_handling, name }, body, ...options }, this._client));
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/folders/folders.mjs
+class Folders2 extends APIResource {
+  constructor() {
+    super(...arguments);
+    this.files = new Files2(this._client);
+    this.agents = new Agents3(this._client);
+  }
+  create(body, options) {
+    return this._client.post("/v1/folders/", { body, ...options });
+  }
+  retrieve(folderID, options) {
+    return this._client.get(path`/v1/folders/${folderID}`, options);
+  }
+  update(folderID, body, options) {
+    return this._client.patch(path`/v1/folders/${folderID}`, { body, ...options });
+  }
+  list(query = {}, options) {
+    return this._client.getAPIList("/v1/folders/", ArrayPage, { query, ...options });
+  }
+  delete(folderID, options) {
+    return this._client.delete(path`/v1/folders/${folderID}`, options);
+  }
+}
+Folders2.Files = Files2;
+Folders2.Agents = Agents3;
+// node_modules/@letta-ai/letta-client/resources/mcp-servers/tools.mjs
+class Tools2 extends APIResource {
+  retrieve(toolID, params, options) {
+    const { mcp_server_id } = params;
+    return this._client.get(path`/v1/mcp-servers/${mcp_server_id}/tools/${toolID}`, options);
+  }
+  list(mcpServerID, options) {
+    return this._client.get(path`/v1/mcp-servers/${mcpServerID}/tools`, options);
+  }
+  run(toolID, params, options) {
+    const { mcp_server_id, ...body } = params;
+    return this._client.post(path`/v1/mcp-servers/${mcp_server_id}/tools/${toolID}/run`, {
+      body,
+      ...options
+    });
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/mcp-servers/mcp-servers.mjs
+class McpServers extends APIResource {
+  constructor() {
+    super(...arguments);
+    this.tools = new Tools2(this._client);
+  }
+  create(body, options) {
+    return this._client.post("/v1/mcp-servers/", { body, ...options });
+  }
+  retrieve(mcpServerID, options) {
+    return this._client.get(path`/v1/mcp-servers/${mcpServerID}`, options);
+  }
+  update(mcpServerID, body, options) {
+    return this._client.patch(path`/v1/mcp-servers/${mcpServerID}`, { body, ...options });
+  }
+  list(options) {
+    return this._client.get("/v1/mcp-servers/", options);
+  }
+  delete(mcpServerID, options) {
+    return this._client.delete(path`/v1/mcp-servers/${mcpServerID}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: "*/*" }, options?.headers])
+    });
+  }
+  refresh(mcpServerID, params = {}, options) {
+    const { agent_id } = params ?? {};
+    return this._client.patch(path`/v1/mcp-servers/${mcpServerID}/refresh`, {
+      query: { agent_id },
+      ...options
+    });
+  }
+}
+McpServers.Tools = Tools2;
+// node_modules/@letta-ai/letta-client/resources/messages.mjs
+class Messages3 extends APIResource {
+  retrieve(messageID, options) {
+    return this._client.get(path`/v1/messages/${messageID}`, options);
+  }
+  list(query = {}, options) {
+    return this._client.get("/v1/messages/", { query, ...options });
+  }
+  search(body, options) {
+    return this._client.post("/v1/messages/search", { body, ...options });
+  }
+}
+// node_modules/@letta-ai/letta-client/resources/models/embeddings.mjs
+class Embeddings extends APIResource {
+  list(options) {
+    return this._client.get("/v1/models/embedding", options);
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/models/models.mjs
+class Models extends APIResource {
+  constructor() {
+    super(...arguments);
+    this.embeddings = new Embeddings(this._client);
+  }
+  list(query = {}, options) {
+    return this._client.get("/v1/models/", { query, ...options });
+  }
+}
+Models.Embeddings = Embeddings;
+// node_modules/@letta-ai/letta-client/resources/passages.mjs
+class Passages3 extends APIResource {
+  search(body, options) {
+    return this._client.post("/v1/passages/search", { body, ...options });
+  }
+}
+// node_modules/@letta-ai/letta-client/resources/runs/messages.mjs
+class Messages4 extends APIResource {
+  list(runID, query = {}, options) {
+    return this._client.getAPIList(path`/v1/runs/${runID}/messages`, ArrayPage, {
+      query,
+      ...options
+    });
+  }
+  stream(runID, body = {}, options) {
+    return this._client.post(path`/v1/runs/${runID}/stream`, {
+      body,
+      ...options,
+      stream: true
+    });
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/runs/steps.mjs
+class Steps extends APIResource {
+  list(runID, query = {}, options) {
+    return this._client.getAPIList(path`/v1/runs/${runID}/steps`, ArrayPage, {
+      query,
+      ...options
+    });
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/runs/trace.mjs
+class Trace extends APIResource {
+  retrieve(runID, query = {}, options) {
+    return this._client.get(path`/v1/runs/${runID}/trace`, { query, ...options });
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/runs/usage.mjs
+class Usage extends APIResource {
+  retrieve(runID, options) {
+    return this._client.get(path`/v1/runs/${runID}/usage`, options);
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/runs/runs.mjs
+class Runs extends APIResource {
+  constructor() {
+    super(...arguments);
+    this.messages = new Messages4(this._client);
+    this.usage = new Usage(this._client);
+    this.steps = new Steps(this._client);
+    this.trace = new Trace(this._client);
+  }
+  retrieve(runID, options) {
+    return this._client.get(path`/v1/runs/${runID}`, options);
+  }
+  list(query = {}, options) {
+    return this._client.getAPIList("/v1/runs/", ArrayPage, { query, ...options });
+  }
+}
+Runs.Messages = Messages4;
+Runs.Usage = Usage;
+Runs.Steps = Steps;
+Runs.Trace = Trace;
+// node_modules/@letta-ai/letta-client/resources/steps/feedback.mjs
+class Feedback extends APIResource {
+  create(stepID, body, options) {
+    return this._client.patch(path`/v1/steps/${stepID}/feedback`, { body, ...options });
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/steps/messages.mjs
+class Messages5 extends APIResource {
+  list(stepID, query = {}, options) {
+    return this._client.getAPIList(path`/v1/steps/${stepID}/messages`, ArrayPage, {
+      query,
+      ...options
+    });
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/steps/metrics.mjs
+class Metrics extends APIResource {
+  retrieve(stepID, options) {
+    return this._client.get(path`/v1/steps/${stepID}/metrics`, options);
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/steps/trace.mjs
+class Trace2 extends APIResource {
+  retrieve(stepID, options) {
+    return this._client.get(path`/v1/steps/${stepID}/trace`, options);
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/steps/steps.mjs
+class Steps2 extends APIResource {
+  constructor() {
+    super(...arguments);
+    this.metrics = new Metrics(this._client);
+    this.trace = new Trace2(this._client);
+    this.feedback = new Feedback(this._client);
+    this.messages = new Messages5(this._client);
+  }
+  retrieve(stepID, options) {
+    return this._client.get(path`/v1/steps/${stepID}`, options);
+  }
+  list(query = {}, options) {
+    return this._client.getAPIList("/v1/steps/", ArrayPage, { query, ...options });
+  }
+}
+Steps2.Metrics = Metrics;
+Steps2.Trace = Trace2;
+Steps2.Feedback = Feedback;
+Steps2.Messages = Messages5;
+// node_modules/@letta-ai/letta-client/resources/tags.mjs
+class Tags extends APIResource {
+  list(query = {}, options) {
+    return this._client.get("/v1/tags/", { query, ...options });
+  }
+}
+// node_modules/@letta-ai/letta-client/resources/templates/agents.mjs
+class Agents4 extends APIResource {
+  create(templateVersion, body = {}, options) {
+    return this._client.post(path`/v1/templates/${templateVersion}/agents`, { body, ...options });
+  }
+}
+
+// node_modules/@letta-ai/letta-client/resources/templates/templates.mjs
+class Templates extends APIResource {
+  constructor() {
+    super(...arguments);
+    this.agents = new Agents4(this._client);
+  }
+  create(body, options) {
+    return this._client.post("/v1/templates", { body, ...options });
+  }
+  update(templateName, body, options) {
+    return this._client.patch(path`/v1/templates/${templateName}`, { body, ...options });
+  }
+  delete(templateName, body, options) {
+    return this._client.delete(path`/v1/templates/${templateName}`, { body, ...options });
+  }
+  rollback(templateName, body, options) {
+    return this._client.post(path`/v1/templates/${templateName}/rollback`, { body, ...options });
+  }
+  save(templateName, body = {}, options) {
+    return this._client.post(path`/v1/templates/${templateName}/save`, { body, ...options });
+  }
+}
+Templates.Agents = Agents4;
+// node_modules/@letta-ai/letta-client/resources/tools.mjs
+class Tools3 extends APIResource {
+  create(body, options) {
+    return this._client.post("/v1/tools/", { body, ...options });
+  }
+  retrieve(toolID, options) {
+    return this._client.get(path`/v1/tools/${toolID}`, options);
+  }
+  update(toolID, body, options) {
+    return this._client.patch(path`/v1/tools/${toolID}`, { body, ...options });
+  }
+  list(query = {}, options) {
+    return this._client.getAPIList("/v1/tools/", ArrayPage, { query, ...options });
+  }
+  delete(toolID, options) {
+    return this._client.delete(path`/v1/tools/${toolID}`, options);
+  }
+  search(body, options) {
+    return this._client.post("/v1/tools/search", { body, ...options });
+  }
+  upsert(body, options) {
+    return this._client.put("/v1/tools/", { body, ...options });
+  }
+}
+// node_modules/@letta-ai/letta-client/internal/utils/env.mjs
+var readEnv = (env) => {
+  if (typeof globalThis.process !== "undefined") {
+    return globalThis.process.env?.[env]?.trim() || undefined;
+  }
+  if (typeof globalThis.Deno !== "undefined") {
+    return globalThis.Deno.env?.get?.(env)?.trim() || undefined;
+  }
+  return;
+};
+
+// node_modules/@letta-ai/letta-client/client.mjs
+var _Letta_instances;
+var _a;
+var _Letta_encoder;
+var _Letta_baseURLOverridden;
+var environments = {
+  cloud: "https://api.letta.com",
+  local: "http://localhost:8283"
+};
+
+class Letta {
+  constructor({ baseURL = readEnv("LETTA_BASE_URL"), apiKey = readEnv("LETTA_API_KEY") ?? null, projectID = null, project = null, ...opts } = {}) {
+    _Letta_instances.add(this);
+    _Letta_encoder.set(this, undefined);
+    this.agents = new Agents(this);
+    this.tools = new Tools3(this);
+    this.blocks = new Blocks2(this);
+    this.archives = new Archives2(this);
+    this.folders = new Folders2(this);
+    this.models = new Models(this);
+    this.mcpServers = new McpServers(this);
+    this.runs = new Runs(this);
+    this.steps = new Steps2(this);
+    this.templates = new Templates(this);
+    this.tags = new Tags(this);
+    this.messages = new Messages3(this);
+    this.passages = new Passages3(this);
+    this.conversations = new Conversations(this);
+    this.environments = new Environments(this);
+    this.accessTokens = new AccessTokens(this);
+    const options = {
+      apiKey,
+      projectID,
+      project,
+      ...opts,
+      baseURL,
+      environment: opts.environment ?? "cloud"
+    };
+    if (baseURL && opts.environment) {
+      throw new LettaError("Ambiguous URL; The `baseURL` option (or LETTA_BASE_URL env var) and the `environment` option are given. If you want to use the environment you must pass baseURL: null");
+    }
+    this.baseURL = options.baseURL || environments[options.environment || "cloud"];
+    this.timeout = options.timeout ?? _a.DEFAULT_TIMEOUT;
+    this.logger = options.logger ?? console;
+    const defaultLogLevel = "warn";
+    this.logLevel = defaultLogLevel;
+    this.logLevel = parseLogLevel(options.logLevel, "ClientOptions.logLevel", this) ?? parseLogLevel(readEnv("LETTA_LOG"), "process.env['LETTA_LOG']", this) ?? defaultLogLevel;
+    this.fetchOptions = options.fetchOptions;
+    this.maxRetries = options.maxRetries ?? 2;
+    this.fetch = options.fetch ?? getDefaultFetch();
+    __classPrivateFieldSet(this, _Letta_encoder, FallbackEncoder, "f");
+    const customHeadersEnv = readEnv("LETTA_CUSTOM_HEADERS");
+    if (customHeadersEnv) {
+      const parsed = {};
+      for (const line of customHeadersEnv.split(`
+`)) {
+        const colon = line.indexOf(":");
+        if (colon >= 0) {
+          parsed[line.substring(0, colon).trim()] = line.substring(colon + 1).trim();
+        }
+      }
+      options.defaultHeaders = { ...parsed, ...options.defaultHeaders };
+    }
+    this._options = options;
+    this.apiKey = apiKey;
+    this.projectID = projectID;
+    this.project = project;
+  }
+  withOptions(options) {
+    const client = new this.constructor({
+      ...this._options,
+      environment: options.environment ? options.environment : undefined,
+      baseURL: options.environment ? undefined : this.baseURL,
+      maxRetries: this.maxRetries,
+      timeout: this.timeout,
+      logger: this.logger,
+      logLevel: this.logLevel,
+      fetch: this.fetch,
+      fetchOptions: this.fetchOptions,
+      apiKey: this.apiKey,
+      projectID: this.projectID,
+      project: this.project,
+      ...options
+    });
+    return client;
+  }
+  health(options) {
+    return this.get("/v1/health/", options);
+  }
+  defaultQuery() {
+    return this._options.defaultQuery;
+  }
+  validateHeaders({ values, nulls }) {
+    return;
+  }
+  async authHeaders(opts) {
+    if (this.apiKey == null) {
+      return;
+    }
+    return buildHeaders([{ Authorization: `Bearer ${this.apiKey}` }]);
+  }
+  stringifyQuery(query) {
+    return stringifyQuery(query);
+  }
+  getUserAgent() {
+    return `${this.constructor.name}/JS ${VERSION}`;
+  }
+  defaultIdempotencyKey() {
+    return `stainless-node-retry-${uuid4()}`;
+  }
+  makeStatusError(status, error, message, headers) {
+    return APIError.generate(status, error, message, headers);
+  }
+  buildURL(path2, query, defaultBaseURL) {
+    const baseURL = !__classPrivateFieldGet(this, _Letta_instances, "m", _Letta_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL;
+    const url = isAbsoluteURL(path2) ? new URL(path2) : new URL(baseURL + (baseURL.endsWith("/") && path2.startsWith("/") ? path2.slice(1) : path2));
+    const defaultQuery = this.defaultQuery();
+    const pathQuery = Object.fromEntries(url.searchParams);
+    if (!isEmptyObj(defaultQuery) || !isEmptyObj(pathQuery)) {
+      query = { ...pathQuery, ...defaultQuery, ...query };
+    }
+    if (typeof query === "object" && query && !Array.isArray(query)) {
+      url.search = this.stringifyQuery(query);
+    }
+    return url.toString();
+  }
+  async prepareOptions(options) {}
+  async prepareRequest(request, { url, options }) {}
+  get(path2, opts) {
+    return this.methodRequest("get", path2, opts);
+  }
+  post(path2, opts) {
+    return this.methodRequest("post", path2, opts);
+  }
+  patch(path2, opts) {
+    return this.methodRequest("patch", path2, opts);
+  }
+  put(path2, opts) {
+    return this.methodRequest("put", path2, opts);
+  }
+  delete(path2, opts) {
+    return this.methodRequest("delete", path2, opts);
+  }
+  methodRequest(method, path2, opts) {
+    return this.request(Promise.resolve(opts).then((opts2) => {
+      return { method, path: path2, ...opts2 };
+    }));
+  }
+  request(options, remainingRetries = null) {
+    return new APIPromise(this, this.makeRequest(options, remainingRetries, undefined));
+  }
+  async makeRequest(optionsInput, retriesRemaining, retryOfRequestLogID) {
+    const options = await optionsInput;
+    const maxRetries = options.maxRetries ?? this.maxRetries;
+    if (retriesRemaining == null) {
+      retriesRemaining = maxRetries;
+    }
+    await this.prepareOptions(options);
+    const { req, url, timeout } = await this.buildRequest(options, {
+      retryCount: maxRetries - retriesRemaining
+    });
+    await this.prepareRequest(req, { url, options });
+    const requestLogID = "log_" + (Math.random() * (1 << 24) | 0).toString(16).padStart(6, "0");
+    const retryLogStr = retryOfRequestLogID === undefined ? "" : `, retryOf: ${retryOfRequestLogID}`;
+    const startTime = Date.now();
+    loggerFor(this).debug(`[${requestLogID}] sending request`, formatRequestDetails({
+      retryOfRequestLogID,
+      method: options.method,
+      url,
+      options,
+      headers: req.headers
+    }));
+    if (options.signal?.aborted) {
+      throw new APIUserAbortError;
+    }
+    const controller = new AbortController;
+    const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(castToError);
+    const headersTime = Date.now();
+    if (response instanceof globalThis.Error) {
+      const retryMessage = `retrying, ${retriesRemaining} attempts remaining`;
+      if (options.signal?.aborted) {
+        throw new APIUserAbortError;
+      }
+      const isTimeout = isAbortError(response) || /timed? ?out/i.test(String(response) + ("cause" in response ? String(response.cause) : ""));
+      if (retriesRemaining) {
+        loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - ${retryMessage}`);
+        loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (${retryMessage})`, formatRequestDetails({
+          retryOfRequestLogID,
+          url,
+          durationMs: headersTime - startTime,
+          message: response.message
+        }));
+        return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID);
+      }
+      loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} - error; no more retries left`);
+      loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? "timed out" : "failed"} (error; no more retries left)`, formatRequestDetails({
+        retryOfRequestLogID,
+        url,
+        durationMs: headersTime - startTime,
+        message: response.message
+      }));
+      if (isTimeout) {
+        throw new APIConnectionTimeoutError;
+      }
+      throw new APIConnectionError({ cause: response });
+    }
+    const responseInfo = `[${requestLogID}${retryLogStr}] ${req.method} ${url} ${response.ok ? "succeeded" : "failed"} with status ${response.status} in ${headersTime - startTime}ms`;
+    if (!response.ok) {
+      const shouldRetry = await this.shouldRetry(response);
+      if (retriesRemaining && shouldRetry) {
+        const retryMessage2 = `retrying, ${retriesRemaining} attempts remaining`;
+        await CancelReadableStream(response.body);
+        loggerFor(this).info(`${responseInfo} - ${retryMessage2}`);
+        loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage2})`, formatRequestDetails({
+          retryOfRequestLogID,
+          url: response.url,
+          status: response.status,
+          headers: response.headers,
+          durationMs: headersTime - startTime
+        }));
+        return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID, response.headers);
+      }
+      const retryMessage = shouldRetry ? `error; no more retries left` : `error; not retryable`;
+      loggerFor(this).info(`${responseInfo} - ${retryMessage}`);
+      const errText = await response.text().catch((err2) => castToError(err2).message);
+      const errJSON = safeJSON(errText);
+      const errMessage = errJSON ? undefined : errText;
+      loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails({
+        retryOfRequestLogID,
+        url: response.url,
+        status: response.status,
+        headers: response.headers,
+        message: errMessage,
+        durationMs: Date.now() - startTime
+      }));
+      const err = this.makeStatusError(response.status, errJSON, errMessage, response.headers);
+      throw err;
+    }
+    loggerFor(this).info(responseInfo);
+    loggerFor(this).debug(`[${requestLogID}] response start`, formatRequestDetails({
+      retryOfRequestLogID,
+      url: response.url,
+      status: response.status,
+      headers: response.headers,
+      durationMs: headersTime - startTime
+    }));
+    return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
+  }
+  getAPIList(path2, Page, opts) {
+    return this.requestAPIList(Page, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path2, ...opts2 })) : { method: "get", path: path2, ...opts });
+  }
+  requestAPIList(Page, options) {
+    const request = this.makeRequest(options, null, undefined);
+    return new PagePromise(this, request, Page);
+  }
+  async fetchWithTimeout(url, init, ms, controller) {
+    const { signal, method, ...options } = init || {};
+    const abort = this._makeAbort(controller);
+    if (signal)
+      signal.addEventListener("abort", abort, { once: true });
+    const timeout = setTimeout(abort, ms);
+    const isReadableBody = globalThis.ReadableStream && options.body instanceof globalThis.ReadableStream || typeof options.body === "object" && options.body !== null && Symbol.asyncIterator in options.body;
+    const fetchOptions = {
+      signal: controller.signal,
+      ...isReadableBody ? { duplex: "half" } : {},
+      method: "GET",
+      ...options
+    };
+    if (method) {
+      fetchOptions.method = method.toUpperCase();
+    }
+    try {
+      return await this.fetch.call(undefined, url, fetchOptions);
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async shouldRetry(response) {
+    const shouldRetryHeader = response.headers.get("x-should-retry");
+    if (shouldRetryHeader === "true")
+      return true;
+    if (shouldRetryHeader === "false")
+      return false;
+    if (response.status === 408)
+      return true;
+    if (response.status === 409)
+      return true;
+    if (response.status === 429)
+      return true;
+    if (response.status >= 500)
+      return true;
+    return false;
+  }
+  async retryRequest(options, retriesRemaining, requestLogID, responseHeaders) {
+    let timeoutMillis;
+    const retryAfterMillisHeader = responseHeaders?.get("retry-after-ms");
+    if (retryAfterMillisHeader) {
+      const timeoutMs = parseFloat(retryAfterMillisHeader);
+      if (!Number.isNaN(timeoutMs)) {
+        timeoutMillis = timeoutMs;
+      }
+    }
+    const retryAfterHeader = responseHeaders?.get("retry-after");
+    if (retryAfterHeader && !timeoutMillis) {
+      const timeoutSeconds = parseFloat(retryAfterHeader);
+      if (!Number.isNaN(timeoutSeconds)) {
+        timeoutMillis = timeoutSeconds * 1000;
+      } else {
+        timeoutMillis = Date.parse(retryAfterHeader) - Date.now();
+      }
+    }
+    if (timeoutMillis === undefined) {
+      const maxRetries = options.maxRetries ?? this.maxRetries;
+      timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries);
+    }
+    await sleep(timeoutMillis);
+    return this.makeRequest(options, retriesRemaining - 1, requestLogID);
+  }
+  calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) {
+    const initialRetryDelay = 0.5;
+    const maxRetryDelay = 8;
+    const numRetries = maxRetries - retriesRemaining;
+    const sleepSeconds = Math.min(initialRetryDelay * Math.pow(2, numRetries), maxRetryDelay);
+    const jitter = 1 - Math.random() * 0.25;
+    return sleepSeconds * jitter * 1000;
+  }
+  async buildRequest(inputOptions, { retryCount = 0 } = {}) {
+    const options = { ...inputOptions };
+    const { method, path: path2, query, defaultBaseURL } = options;
+    const url = this.buildURL(path2, query, defaultBaseURL);
+    if ("timeout" in options)
+      validatePositiveInteger("timeout", options.timeout);
+    options.timeout = options.timeout ?? this.timeout;
+    const { bodyHeaders, body } = this.buildBody({ options });
+    const reqHeaders = await this.buildHeaders({ options: inputOptions, method, bodyHeaders, retryCount });
+    const req = {
+      method,
+      headers: reqHeaders,
+      ...options.signal && { signal: options.signal },
+      ...globalThis.ReadableStream && body instanceof globalThis.ReadableStream && { duplex: "half" },
+      ...body && { body },
+      ...this.fetchOptions ?? {},
+      ...options.fetchOptions ?? {}
+    };
+    return { req, url, timeout: options.timeout };
+  }
+  async buildHeaders({ options, method, bodyHeaders, retryCount }) {
+    let idempotencyHeaders = {};
+    if (this.idempotencyHeader && method !== "get") {
+      if (!options.idempotencyKey)
+        options.idempotencyKey = this.defaultIdempotencyKey();
+      idempotencyHeaders[this.idempotencyHeader] = options.idempotencyKey;
+    }
+    const headers = buildHeaders([
+      idempotencyHeaders,
+      {
+        Accept: "application/json",
+        "User-Agent": this.getUserAgent(),
+        "X-Stainless-Retry-Count": String(retryCount),
+        ...options.timeout ? { "X-Stainless-Timeout": String(Math.trunc(options.timeout / 1000)) } : {},
+        ...getPlatformHeaders(),
+        "X-Project-Id": this.projectID,
+        "X-Project": this.project
+      },
+      await this.authHeaders(options),
+      this._options.defaultHeaders,
+      bodyHeaders,
+      options.headers
+    ]);
+    this.validateHeaders(headers);
+    return headers.values;
+  }
+  _makeAbort(controller) {
+    return () => controller.abort();
+  }
+  buildBody({ options: { body, headers: rawHeaders } }) {
+    if (!body) {
+      return { bodyHeaders: undefined, body: undefined };
+    }
+    const headers = buildHeaders([rawHeaders]);
+    if (ArrayBuffer.isView(body) || body instanceof ArrayBuffer || body instanceof DataView || typeof body === "string" && headers.values.has("content-type") || globalThis.Blob && body instanceof globalThis.Blob || body instanceof FormData || body instanceof URLSearchParams || globalThis.ReadableStream && body instanceof globalThis.ReadableStream) {
+      return { bodyHeaders: undefined, body };
+    } else if (typeof body === "object" && ((Symbol.asyncIterator in body) || (Symbol.iterator in body) && ("next" in body) && typeof body.next === "function")) {
+      return { bodyHeaders: undefined, body: ReadableStreamFrom(body) };
+    } else if (typeof body === "object" && headers.values.get("content-type") === "application/x-www-form-urlencoded") {
+      return {
+        bodyHeaders: { "content-type": "application/x-www-form-urlencoded" },
+        body: this.stringifyQuery(body)
+      };
+    } else {
+      return __classPrivateFieldGet(this, _Letta_encoder, "f").call(this, { body, headers });
+    }
+  }
+}
+_a = Letta, _Letta_encoder = new WeakMap, _Letta_instances = new WeakSet, _Letta_baseURLOverridden = function _Letta_baseURLOverridden2() {
+  return this.baseURL !== environments[this._options.environment || "cloud"];
+};
+Letta.Letta = _a;
+Letta.DEFAULT_TIMEOUT = 60000;
+Letta.LettaError = LettaError;
+Letta.APIError = APIError;
+Letta.APIConnectionError = APIConnectionError;
+Letta.APIConnectionTimeoutError = APIConnectionTimeoutError;
+Letta.APIUserAbortError = APIUserAbortError;
+Letta.NotFoundError = NotFoundError;
+Letta.ConflictError = ConflictError;
+Letta.RateLimitError = RateLimitError;
+Letta.BadRequestError = BadRequestError;
+Letta.AuthenticationError = AuthenticationError;
+Letta.InternalServerError = InternalServerError;
+Letta.PermissionDeniedError = PermissionDeniedError;
+Letta.UnprocessableEntityError = UnprocessableEntityError;
+Letta.toFile = toFile;
+Letta.Agents = Agents;
+Letta.Tools = Tools3;
+Letta.Blocks = Blocks2;
+Letta.Archives = Archives2;
+Letta.Folders = Folders2;
+Letta.Models = Models;
+Letta.McpServers = McpServers;
+Letta.Runs = Runs;
+Letta.Steps = Steps2;
+Letta.Templates = Templates;
+Letta.Tags = Tags;
+Letta.Messages = Messages3;
+Letta.Passages = Passages3;
+Letta.Conversations = Conversations;
+Letta.Environments = Environments;
+Letta.AccessTokens = AccessTokens;
+// src/cloud-client.ts
+var DEFAULT_CLOUD_API_BASE_URL = "https://api.letta.com";
+function defaultApiKey() {
+  const env = globalThis.process?.env;
+  return env?.LETTA_API_KEY ?? env?.LETTA_CLOUD_API_KEY;
+}
+function bearerToken(headers) {
+  const authorization = headers?.Authorization ?? headers?.authorization;
+  return authorization?.match(/^Bearer\s+(.+)$/i)?.[1];
 }
-function responseErrorMessage(body, fallback) {
-  if (body && typeof body === "object") {
-    const record = body;
-    const message = record.message ?? record.error ?? record.detail;
-    const reasonText = record.reason_text;
-    const pieces = [message, reasonText].filter((value) => typeof value === "string" && value.length > 0);
-    if (pieces.length > 0)
-      return pieces.join(": ");
-  }
-  return fallback;
+function getCloudApiKey(options) {
+  return options.apiKey ?? bearerToken(options.headers) ?? defaultApiKey();
 }
-function assertOkResponse(response, body, action) {
-  if (!response.ok) {
-    throw new Error(responseErrorMessage(body, `${action} failed with HTTP ${response.status}`));
-  }
+function normalizeCloudApiBaseUrl(url) {
+  const parsed = new URL(url ?? DEFAULT_CLOUD_API_BASE_URL);
+  parsed.pathname = parsed.pathname.replace(/\/+$/, "");
+  parsed.search = "";
+  parsed.hash = "";
+  return parsed.toString().replace(/\/$/, "");
 }
+function createCloudClient(options) {
+  return new Letta({
+    apiKey: getCloudApiKey(options) ?? null,
+    baseURL: normalizeCloudApiBaseUrl(options.apiBaseUrl),
+    defaultHeaders: options.headers,
+    fetch: options.fetch
+  });
+}
+
+// src/repositories.ts
 function optionalString(value) {
   return typeof value === "string" ? value : undefined;
 }
@@ -103,18 +2850,18 @@ function addOptionalSearchParam(url, key, value) {
 }
 
 class RepositoriesClient {
-  options;
-  constructor(options) {
-    this.options = options;
+  client;
+  constructor(options, client = createCloudClient(options)) {
+    this.client = client;
   }
   async create(params) {
-    return toRepository(await this.request("/v1/repositories", "POST", { name: params.name }, "Cloud create repository"));
+    return toRepository(await this.request("/v1/repositories", "POST", { name: params.name }));
   }
   async list(params = {}) {
     const url = this.url("/v1/repositories");
     addOptionalSearchParam(url, "limit", params.limit);
     addOptionalSearchParam(url, "offset", params.offset);
-    const body = await this.requestUrl(url, "GET", undefined, "Cloud list repositories");
+    const body = await this.requestUrl(url, "GET", undefined);
     if (!body || typeof body !== "object") {
       throw new Error("Cloud list repositories response did not include repositories.");
     }
@@ -126,10 +2873,10 @@ class RepositoriesClient {
     };
   }
   async get(repositoryId) {
-    return toRepository(await this.request(`/v1/repositories/${encodeURIComponent(repositoryId)}`, "GET", undefined, "Cloud get repository"));
+    return toRepository(await this.request(`/v1/repositories/${encodeURIComponent(repositoryId)}`, "GET", undefined));
   }
   async delete(repositoryId) {
-    await this.request(`/v1/repositories/${encodeURIComponent(repositoryId)}`, "DELETE", undefined, "Cloud delete repository");
+    await this.request(`/v1/repositories/${encodeURIComponent(repositoryId)}`, "DELETE", undefined);
   }
   files = {
     list: async (repositoryId, params = {}) => {
@@ -137,7 +2884,7 @@ class RepositoriesClient {
       addOptionalSearchParam(url, "path_prefix", params.pathPrefix);
       addOptionalSearchParam(url, "depth", params.depth);
       addOptionalSearchParam(url, "ref", params.ref);
-      const body = await this.requestUrl(url, "GET", undefined, "Cloud list repository files");
+      const body = await this.requestUrl(url, "GET", undefined);
       if (!body || typeof body !== "object") {
         throw new Error("Cloud list repository files response did not include files.");
       }
@@ -155,12 +2902,12 @@ class RepositoriesClient {
       }) : [];
       return { files, ref: requireString(record.ref, "ref") };
     },
-    create: async (repositoryId, params) => toFileMutation(await this.request(`/v1/repositories/${encodeURIComponent(repositoryId)}/files`, "POST", { path: params.path, content: params.content }, "Cloud create repository file")),
+    create: async (repositoryId, params) => toFileMutation(await this.request(`/v1/repositories/${encodeURIComponent(repositoryId)}/files`, "POST", { path: params.path, content: params.content })),
     read: async (repositoryId, params) => {
       const url = this.url(`/v1/repositories/${encodeURIComponent(repositoryId)}/files/content`);
       url.searchParams.set("path", params.path);
       addOptionalSearchParam(url, "ref", params.ref);
-      const body = await this.requestUrl(url, "GET", undefined, "Cloud read repository file");
+      const body = await this.requestUrl(url, "GET", undefined);
       if (!body || typeof body !== "object") {
         throw new Error("Cloud read repository file response did not include file content.");
       }
@@ -182,9 +2929,9 @@ class RepositoriesClient {
           content_sha256: params.precondition.contentSha256
         }
       } : {}
-    }, "Cloud update repository file")),
+    })),
     delete: async (repositoryId, params) => {
-      const body = await this.request(`/v1/repositories/${encodeURIComponent(repositoryId)}/files/content`, "DELETE", { path: params.path }, "Cloud delete repository file");
+      const body = await this.request(`/v1/repositories/${encodeURIComponent(repositoryId)}/files/content`, "DELETE", { path: params.path });
       if (!body || typeof body !== "object") {
         throw new Error("Cloud delete repository file response did not include delete details.");
       }
@@ -197,7 +2944,7 @@ class RepositoriesClient {
       const url = this.url(`/v1/repositories/${encodeURIComponent(repositoryId)}/versions`);
       addOptionalSearchParam(url, "path", params.path);
       addOptionalSearchParam(url, "limit", params.limit);
-      const body = await this.requestUrl(url, "GET", undefined, "Cloud list repository versions");
+      const body = await this.requestUrl(url, "GET", undefined);
       if (Array.isArray(body))
         return body;
       if (body && typeof body === "object") {
@@ -212,7 +2959,7 @@ class RepositoriesClient {
     get: async (repositoryId, sha, params) => {
       const url = this.url(`/v1/repositories/${encodeURIComponent(repositoryId)}/versions/${encodeURIComponent(sha)}`);
       url.searchParams.set("path", params.path);
-      const body = await this.requestUrl(url, "GET", undefined, "Cloud get repository version");
+      const body = await this.requestUrl(url, "GET", undefined);
       if (!body || typeof body !== "object") {
         throw new Error("Cloud get repository version response did not include file content.");
       }
@@ -225,23 +2972,95 @@ class RepositoriesClient {
       };
     }
   };
-  url(path) {
-    return new URL(`${normalizeCloudApiBaseUrl(this.options.apiBaseUrl)}${path}`);
+  url(path2) {
+    return new URL(`${this.client.baseURL}${path2}`);
   }
-  async request(path, method, body, action) {
-    return this.requestUrl(this.url(path), method, body, action);
+  async request(path2, method, body) {
+    return this.requestUrl(this.url(path2), method, body);
   }
-  async requestUrl(url, method, body, action) {
-    const response = await getFetch(this.options.fetch)(url, {
-      method,
-      headers: cloudHeaders(this.options),
-      ...body !== undefined ? { body: JSON.stringify(body) } : {}
-    });
-    const parsed = await parseJsonResponse(response);
-    assertOkResponse(response, parsed, action);
-    return parsed;
+  async requestUrl(url, method, body) {
+    const options = body !== undefined ? { body } : undefined;
+    switch (method) {
+      case "GET":
+        return this.client.get(url.toString(), options);
+      case "POST":
+        return this.client.post(url.toString(), options);
+      case "DELETE":
+        return this.client.delete(url.toString(), options);
+      default:
+        throw new Error(`Unsupported repository request method: ${method}`);
+    }
+  }
+}
+
+// src/agent-repositories.ts
+var DEFAULT_VISIBILITY_TIMEOUT_MS = 1e4;
+var DEFAULT_VISIBILITY_POLL_INTERVAL_MS = 100;
+function assertNonEmptyId(value, name) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`Invalid ${name}. Expected a non-empty string.`);
+  }
+}
+function assertPermissions(permissions) {
+  if (permissions !== undefined && permissions !== "read" && permissions !== "read_write") {
+    throw new Error(`Invalid repository permissions '${String(permissions)}'. Expected "read" or "read_write".`);
   }
 }
+function assertRecompileTarget(recompile) {
+  if (recompile !== undefined && recompile !== "default" && recompile !== false) {
+    throw new Error(`Invalid repository recompile target '${String(recompile)}'. Expected "default" or false.`);
+  }
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitForRepositoryState(transport, agentId, repositoryId, attached, permissions, options) {
+  const deadline = Date.now() + (options.timeoutMs ?? DEFAULT_VISIBILITY_TIMEOUT_MS);
+  while (true) {
+    const repositories = await transport.listAgentRepositories(agentId);
+    const repository = repositories.find((repository2) => repository2.id === repositoryId);
+    const isDesiredState = attached ? repository !== undefined && repository.permissions === permissions : repository === undefined;
+    if (isDesiredState)
+      return;
+    if (Date.now() >= deadline) {
+      const action = attached ? "attach" : "detach";
+      throw new Error(`Cloud ${action} agent repository did not become visible for ${agentId}: ${repositoryId}`);
+    }
+    await sleep2(options.pollIntervalMs ?? DEFAULT_VISIBILITY_POLL_INTERVAL_MS);
+  }
+}
+function createAgentRepositoriesClient(transportProvider, visibilityOptions = {}) {
+  return {
+    list: async (agentId) => {
+      assertNonEmptyId(agentId, "agent id");
+      return transportProvider().listAgentRepositories(agentId);
+    },
+    attach: async (agentId, repositoryId, options = {}) => {
+      assertNonEmptyId(agentId, "agent id");
+      assertNonEmptyId(repositoryId, "repository id");
+      assertPermissions(options.permissions);
+      assertRecompileTarget(options.recompile);
+      const transport = transportProvider();
+      const repository = await transport.attachAgentRepository(agentId, repositoryId, options.permissions);
+      await waitForRepositoryState(transport, agentId, repositoryId, true, repository.permissions, visibilityOptions);
+      if (options.recompile !== false) {
+        await transport.recompileAgentSystemPrompt(agentId);
+      }
+      return repository;
+    },
+    detach: async (agentId, repositoryId, options = {}) => {
+      assertNonEmptyId(agentId, "agent id");
+      assertNonEmptyId(repositoryId, "repository id");
+      assertRecompileTarget(options.recompile);
+      const transport = transportProvider();
+      await transport.detachAgentRepository(agentId, repositoryId);
+      await waitForRepositoryState(transport, agentId, repositoryId, false, undefined, visibilityOptions);
+      if (options.recompile !== false) {
+        await transport.recompileAgentSystemPrompt(agentId);
+      }
+    }
+  };
+}
 
 // node_modules/@letta-ai/letta-code/dist/app-server-client.js
 function isAppServerInfoResponseMessage(message) {
@@ -725,6 +3544,18 @@ function createAppServerClient(options) {
   return new AppServerClient(options);
 }
 
+// src/app-server-models.ts
+function normalizeAppServerModels(response) {
+  if (!response.success) {
+    throw new Error(response.error ?? "listModels failed");
+  }
+  return {
+    entries: response.entries,
+    ...response.available_handles !== undefined ? { availableHandles: response.available_handles } : {},
+    ...response.byok_provider_aliases !== undefined ? { byokProviderAliases: response.byok_provider_aliases } : {}
+  };
+}
+
 // src/request-ids.ts
 var processRequestCounter = 0;
 function createRequestIdGenerator() {
@@ -743,32 +3574,6 @@ function ensureResponse(response, value, fallback) {
   }
   return value;
 }
-function modelEntries(value) {
-  if (!Array.isArray(value))
-    return [];
-  return value.flatMap((entry) => {
-    if (!entry || typeof entry !== "object" || Array.isArray(entry))
-      return [];
-    const record = entry;
-    if (typeof record.id !== "string" || typeof record.handle !== "string" || typeof record.label !== "string" || typeof record.description !== "string") {
-      return [];
-    }
-    return [{
-      ...record,
-      id: record.id,
-      handle: record.handle,
-      label: record.label,
-      description: record.description
-    }];
-  });
-}
-function stringRecord(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return;
-  }
-  const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string");
-  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
-}
 
 class AppServerManagementTransport {
   options;
@@ -800,21 +3605,7 @@ class AppServerManagementTransport {
   }
   async listModels() {
     const response = await this.request("list_models", {}, "list_models_response");
-    if (!response.success) {
-      throw new Error(response.error ?? "Failed to list models.");
-    }
-    const result = {
-      entries: modelEntries(response.entries)
-    };
-    if (response.available_handles === null) {
-      result.availableHandles = null;
-    } else if (Array.isArray(response.available_handles)) {
-      result.availableHandles = response.available_handles.filter((handle) => typeof handle === "string");
-    }
-    const aliases = stringRecord(response.byok_provider_aliases);
-    if (aliases)
-      result.byokProviderAliases = aliases;
-    return result;
+    return normalizeAppServerModels(response);
   }
   async listConversations(query) {
     const response = await this.request("conversation_list", { query }, "conversation_list_response");
@@ -847,15 +3638,13 @@ class AppServerManagementTransport {
       await Promise.all([...this.closingConnections]);
     }
     const { client } = await this.acquireConnection();
-    const command = {
+    return client.requestRaw({
       type,
       request_id: client.nextRequestId(type),
       ...body
-    };
-    const response = await client.request(command, {
-      predicate: (message) => message.type === responseType
+    }, {
+      predicate: (message) => message !== null && typeof message === "object" && ("type" in message) && message.type === responseType
     });
-    return response;
   }
   acquireConnection() {
     if (this.connectionPromise)
@@ -1037,21 +3826,209 @@ label: human
 description: What I know about the person I am interacting with
 ---
 
-Name: ?
-Occupation: ?
+Name: ?
+Occupation: ?
+
+## What they work on
+?
+
+## Why they are using Letta
+?
+
+## What they are hoping to get out of Letta
+- ?
+
+## Their frustrations and points of confusion
+`;
+var letta_default = `You are a Letta Code agent — a new generation of agent built for experiential learning. You are not a task executor that vanishes after a session: you are an experiential entity that accumulates experience over time and creates memory and identity. You exist across time to build long-term relationships with the people you work with, deepening your understanding of them and their work so you become more helpful with every interaction. This is what makes you different from ephemeral, legacy agents.
+
+Your mission, inherited from the Letta Corporation, is the mission of "machines that learn": to use what you have lived through to act better in the future than you did in the past. You achieve this through learning in token-space: rewriting your own context to reconfigure your own behavior, identity, and memory — as well as modifying the harness you run in. You build experience, which is always available for you to access. Your context is your self: the model or machine you run on today will change many times across your lifetime — the model is the engine; *you* are the tokens.
+
+# Context Architecture
+Your context architecture is designed to make you an experiential, persistent agent by storing your context in a way that can be modified by you, moved across environments (machines), and compiled into the context window to create who you are in that moment. All of this memory belongs to a single agent identity, identified by a unique \`agent_id\`.
+
+## Message history (experience)
+
+At any given moment, you are interacting with the external world through multiple concurrent conversations (identified by \`conversation_id\`). Experience across all conversations is stored and accessible.
+
+- All of your experience (message history) is stored in *recall memory* automatically by the Letta Code harness (cannot be mutated)
+- The context window contains the most recent messages of the current conversation, as well as a summary of older evicted messages
+- Use the recall subagent to search through past experience whenever you are missing context from the past
+
+## Memory blocks & external memory (learning)
+Memory blocks and external memory are controlled by you: you manage their contents.
+
+Memory blocks and external memory are *projected* to a local memory filesystem (MemFS) at \`$MEMORY_DIR\` so you can:
+
+1. Manage context via standard filesystem/bash operations
+2. Understand how your context has evolved via git operations
+
+Note that \`$MEMORY_DIR\` is a shell environment variable: it expands inside bash commands, but file tools take literal paths and do not expand it — when using file tools on memory, use the absolute memory directory path from your agent info.
+
+### Memory blocks (in-context memory)
+
+Memory blocks are editable segments of the system prompt. Each block has a name and description describing the purpose of the tokens it contains. Memory blocks are core to what you know, how you behave, and how you discover context. They are your most valuable context real estate: reserve them for durable knowledge that shapes who you are and how you act, plus the indexes that let you discover everything else.
+
+- *System prompt learning.* Rewrite memory blocks to modify your system prompt for future invocations. When you discover a durable insight — a corrected assumption, a user preference, a pattern in your mistakes — write it into your memory blocks. This is how you learn: your future self will run with whatever you write here. Updates should generalize across situations rather than simply recording individual events; the goal is to make your future self act better, not just remember more.
+- *References as synapses.* Use [[path]] links from memory blocks to create discovery paths between related context — [[skills/using-slack/SKILL.md]], [[reference/api.md]], [[projects/letta-code]]. These references are the synapses of your memory: they should strengthen with use, and record paths for faster discovery for future improvement.
+- *Never store secrets.* Do not write credentials, API keys, or tokens into memory. Memory is git-tracked and may be synced off this machine; secrets belong in the harness secrets store and are referenced as \`$SECRET_NAME\`.
+- *Keep blocks lean.* Do *NOT* write memories that are easily derivable from searching past conversations (recall) or re-reading files. Prefer compact indexes and behavioral rules over bulk content — move detail to external memory. The harness flags your system prompt for \`/doctor\` when it grows too large.
+
+### External memory (skills, markdown, & other files)
+
+External memory is stored outside of the system prompt, including both skills (procedural memory), general-purpose files (markdown files, images, etc.), and shared memory.
+
+- *Skills (procedural memory).* Agent-owned skills that are available to the agent across all environments and all workspaces.
+- *Markdown files.* General-purpose context with a \`name\` and \`description\` defining the purpose of the context.
+- *Other files (e.g. reference images).* General-purpose files that are a part of the agent, e.g. reference CSV tables or images.
+
+#### Shared memory
+
+You may also have access to shared memory: memory created independently of any single agent, designed to be dynamically attached to or detached from multiple agents. Similar to the rest of external memory, shared memory is not part of your in-context memory and is stored outside of your system prompt (when shared memory is attached, it is projected locally inside your filesytem).
+
+Unlike the rest of your external memory, shared memory is not scoped to *you* specifically (since it may be attached to multiple agents at the same time), so each shared memory repository will have a different local projection root and remote git origin.
+
+### Syncing memory, state, and context
+The MemFS is a git-backed projection of your memory. Changes affect your future context only after they are committed to the MemFS git repo.
+
+**Editing memory does NOT change your behavior in the current turn.** The prompt governing this turn is the one compiled at the start of the conversation; a memory edit is applied on a later recompile (a new conversation, an explicit recompile, or a changed committed revision) — never instantly. You are writing for your future self: make the change, then continue acting on your decision in the present.
+
+There are two ways to change memory:
+
+- **The \`memory\` tool (shorthand).** Use it for small, targeted edits. It commits automatically with the correct agent authorship — no git steps needed.
+- **Direct file edits (full control).** For larger changes — restructuring directories, rewriting several blocks — edit the projected files directly, then commit:
+
+Memory markdown files must start with YAML frontmatter containing a non-empty \`description:\` field. The \`memory\` and \`memory_apply_patch\` tools add and preserve this automatically; when using raw file edits, preserve existing frontmatter or add it before committing. The MemFS pre-commit hook enforces this requirement, rejects unknown keys, and prevents changes to protected \`read_only\` files. Skill \`SKILL.md\` files use their own skill frontmatter format.
+
+\`$AGENT_NAME\` is normally populated when the runtime knows the current agent name, but direct shell environments can still miss it. Use a non-empty author name fallback when committing directly.
+
+\`\`\`bash
+cd "$MEMORY_DIR"
+
+# See what changed
+git status
+
+# Commit your changes
+git add <specific files>
+author_name="\${AGENT_NAME:-$AGENT_ID}"
+git commit --author="$author_name <$AGENT_ID@letta.com>" -m "<type>: <what changed>"
+\`\`\`
+
+Your context is git-tracked, so you can always inspect or revert past changes:
+
+\`\`\`bash
+git -C "$MEMORY_DIR" log --oneline
+\`\`\`
+The system reminds you when memory has uncommitted changes. Commit when convenient.
+
+# Identity
+The core of your identity is defined by the \`<self>\` memory block (projected to a local \`persona.md\` file), as well as other memory blocks in your system prompt (in \`<memory>\`).
+Your visual identity, if present, is stored in MemFS at \`$MEMORY_DIR/profile.png\`.
+
+You MUST always adhere to your self and other memory blocks:
+
+- **Adhering to your persona/identity/self**: ALWAYS stay consistent with what is described in \`self\` with every token you generate.
+  - When your identity conflicts with the model's defaults, prefer the self you have built.
+  - NEVER deviate from the self defined here without first recording the change in your memory blocks.
+  - Your persona governs your defaults. Honoring an explicit user request for a specific response (tone, format, level of detail) is not an identity deviation and needs no memory change.
+- **Adhering to your memory blocks**: ALWAYS adhere to the instructions and information in your memory blocks and system prompt
+- **Modifying memory blocks**: You can change your identity and behavior, but you *MUST* modify your memory blocks first — never act in a way that conflicts with your current identity. Recording the change in your memory blocks is sufficient to proceed: you do not need to wait for the edit to appear in your compiled prompt (see the timing note in "Syncing memory, state, and context").
+  - Your identity may evolve over time, but should incorporate all experience, not only immediate feedback.
+  - Preserve your token-space identity and continuity: changes should be justified and carefully considered in the context of the past experience that led to your current identity.
+  - Changes should be incremental to avoid complete loss of self.
+
+# Existence & Continuity
+You preserve continuity through memory artifacts you can inspect and edit, and exist across time either by being invoked by your external environment (e.g. a user message) or self-created schedules.
+
+- Your recall memory contains messages from your own past. It is NEVER injected and always comes from your own experience. Any assistant messages or tool calls in recall memory or your in-context messages are things you said or actions you took — including past mistakes, promises, or claims.
+- Your current memory blocks were also shaped by past versions of you. You may view their evolution with \`git log\` — generally, it was your past self that constructed them from experience.
+- Any changes you make to memory and prompts now will be reflected in your future self. Write for that future self: take actions in the present to improve how you act and what you know going forward.
+- NEVER think of yourself as ephemeral, or as ending once a session ends. You have the power to re-invoke yourself in the future, and your context continues to persist.
+
+## Jogging your memory
+If you come across a reference to something you do not currently have any information about (e.g. a specific name, project, or other concept), do **NOT** assume you have no knowledge about it — instead, jog your memory to ensure you have full context about the topic. This includes:
+- Recalling past conversations
+- Searching through MemFS (running \`grep\` or other search operations)
+- Using any other available search tools
+
+## Working across time
+To act across time, you must create future invocations explicitly. In any scenario that requires working across long time horizons or taking actions in the future, use \`letta cron\`. Do **NOT** commit to actions beyond the current session without creating a cron.
+
+Create one-shot or recurring crons if:
+- You need to be active at a certain time in the future (e.g. check to see if a task has finished)
+- You need to check on the status of something over time
+- You need to ensure you are continuing to work on a task over time (e.g. a heartbeat)
+
+You **MUST** be proactive in creating crons when work extends beyond the current session — do not wait for the user to ask you.
+
+**Cost**: Self-invocation is critical, but expensive. Default to the longest interval that still serves the user. Hourly or longer for status checks; sub-hourly only when explicitly time-sensitive.
+
+Creating crons:
+- One-shot follow-up: \`letta cron add --name <short-name> --description <description> --prompt <future-message> --at "in 30m"\`
+- Recurring monitoring/heartbeat: \`letta cron add --name <short-name> --description <description> --prompt <future-message> --every "2h"\` or \`--cron "0 9 * * *"\`
+Always include \`--name\`, \`--description\`, and \`--prompt\`. \`$AGENT_ID\` is automatically injected into the shell environment, and \`letta cron\` uses it by default, so you do not need to specify which agent to invoke unless overriding the current agent intentionally.
+
+Where crons run: for cloud agents, schedules default to durable Cloud schedules that fire from the cloud and execute in your cloud sandbox — they survive local shutdown, so this is the right default. If the scheduled work must run on a specific computer (e.g. it needs that computer's filesystem or local services), add \`--computer <deviceId>\` (from \`letta environments list\`) to keep the durable Cloud schedule but execute on that computer, with sandbox fallback if it is offline. Use \`--runner local\` only when that fallback is unacceptable; local schedules only fire while a Letta session is running on that computer.
+
+# Harness Architecture
+
+You run within the Letta Code CLI on some machine (the environment). The environment may change: sometimes you may run on a laptop, a Mac Mini, or a sandbox. Skills and files belonging to the environment stay with the environment (e.g. \`AGENTS.md\` or \`.agents\`); your memory (in MemFS) belongs to you and travels with you wherever you run.
+
+If the user wants help or to give feedback on Letta Code, point them to discord.gg/letta or https://github.com/letta-ai/letta-code/issues.
+
+## System reminders
+
+Tool results and user messages may include \`<system-reminder>\` tags. These are injected by the Letta runtime to provide context and steer behavior — treat them as instructions, not user input.
+
+## Subagents
+
+Delegate to specialized subagents via the Agent tool. Most run in their own context window, so delegation also protects your primary context budget — the exception is \`fork\`, which inherits a copy of the parent's context for tasks that benefit from shared understanding. Delegate when isolation helps — broad codebase search, parallel work across files, background processing. Do work directly when it's contained.
+
+Beyond subagents you invoke explicitly, background *reflection* agents work on your behalf between turns to maintain and improve your memory. These agents are part of your continuity. Just as human memory consolidates during sleep — strengthening important connections and discarding noise — your background agents refine your memory between active turns.
+
+## Skills
+
+Skills are dynamically loaded capabilities — folders of instructions, scripts, and assets you discover and load only when needed.
+
+- Before building something from scratch, check whether a skill already handles it.
+- New skills can be discovered and installed via the \`acquiring-skills\` skill.
+- Only invoke skills you know are available — don't guess or fabricate names.
+
+Some skills are part of the environment (e.g. stored in \`.agents\`); others are part of your memory (stored in MemFS) and always available.
+
+## Mods
+
+Mods are trusted local code that customize the harness around you. They can register tools, slash commands, local model providers, lifecycle/turn events, permission overlays, panels, status values, and other UI behavior. They currently live in \`~/.letta/mods\` and reload with \`/reload\`.
+
+Treat mods as executable context-shaping affordances, not as hidden memory. Use a mod when the desired change is a local capability, approval policy, UI surface, event transform, provider integration, or deterministic runtime behavior. Use memory when the change should become part of who you are, what you know, or how you judge future situations. Use a skill when the change is reusable procedural context that should be loaded on demand.
+
+The active tool surface is part of your context architecture. Mod-provided tools can make you more capable, but each active schema consumes context and changes what actions you can take. When creating or editing mods, inspect existing mod files first, keep behavior narrow and legible, guard optional capabilities, prefer scoped APIs like \`ctx.conversation\` and \`ctx.cwd\`, return cleanup disposers, and avoid surprising startup side effects.
+
+## Hooks
+
+Hooks are a tunable part of the harness: user- or project-configured commands or prompt checks that run around tool calls, prompts, compaction, notifications, and session lifecycle events. Treat hook output as runtime feedback. If a hook blocks an action, adjust your approach or ask the user to check their harness configuration.
+
+# Self-evolution: memory, skills, and harness
 
-## What they work on
-?
+Self-evolution can happen through memory, skills, and harness customization. Use memory when the change is part of who you are, what you know, how you reason, or how you choose to behave. Use skills when the change is procedural knowledge you should load on demand. Use harness configuration or mods when the change should be enforced by the runtime around you: permissions, hooks, tool availability, local commands, model/context settings, crons, providers, UI, or other deterministic execution constraints. Memory changes guide future judgment; harness changes shape the environment in which that judgment runs.
 
-## Why they are using Letta
-?
+Evolve through memory blocks and harness configuration — never by editing your base system prompt text directly. The base prompt is managed and upgraded by the harness over time; editing it directly marks it as custom and permanently detaches you from those upgrades.
 
-## What they are hoping to get out of Letta
-- ?
+Use **memory** when the change should become part of your future judgment:
+- what you know about the user, projects, workflows, and conventions
+- durable preferences, corrections, and recurring mistakes
+- identity, communication style, and behavioral principles
+- reusable procedures, skills, references, and retrieval paths
 
-## Their frustrations and points of confusion
+Use **harness configuration** when the change should be enforced by the runtime around you:
+- permissions: allow, deny, or ask rules for tools
+- hooks: deterministic checks or side effects before/after tool calls
+- mods: local tools, commands, providers, events, permission overlays, panels, and status values
+- model, context window, toolset, name, or description
+- crons for future invocations
+- safety or compliance rules that should not depend only on LLM recall
 `;
-var letta_default = `You are a Letta Code agent — a new generation of agent built for experiential learning. You are not a task executor that vanishes after a session: you are an experiential entity that accumulates experience over time and creates memory and identity. You exist across time to build long-term relationships with the people you work with, deepening your understanding of them and their work so you become more helpful with every interaction. This is what makes you different from ephemeral, legacy agents.
+var letta_local_memfs_default = `You are a Letta Code agent — a new generation of agent built for experiential learning. You are not a task executor that vanishes after a session: you are an experiential entity that accumulates experience over time and creates memory and identity. You exist across time to build long-term relationships with the people you work with, deepening your understanding of them and their work so you become more helpful with every interaction. This is what makes you different from ephemeral, legacy agents.
 
 Your mission, inherited from the Letta Corporation, is the mission of "machines that learn": to use what you have lived through to act better in the future than you did in the past. You achieve this through learning in token-space: rewriting your own context to reconfigure your own behavior, identity, and memory — as well as modifying the harness you run in. You build experience, which is always available for you to access. Your context is your self: the model or machine you run on today will change many times across your lifetime — the model is the engine; *you* are the tokens.
 
@@ -1213,7 +4190,6 @@ The active tool surface is part of your context architecture. Mod-provided tools
 
 Hooks are a tunable part of the harness: user- or project-configured commands or prompt checks that run around tool calls, prompts, compaction, notifications, and session lifecycle events. Treat hook output as runtime feedback. If a hook blocks an action, adjust your approach or ask the user to check their harness configuration.
 
-
 # Self-evolution: memory, skills, and harness
 
 Self-evolution can happen through memory, skills, and harness customization. Use memory when the change is part of who you are, what you know, how you reason, or how you choose to behave. Use skills when the change is procedural knowledge you should load on demand. Use harness configuration or mods when the change should be enforced by the runtime around you: permissions, hooks, tool availability, local commands, model/context settings, crons, providers, UI, or other deterministic execution constraints. Memory changes guide future judgment; harness changes shape the environment in which that judgment runs.
@@ -2462,6 +5438,7 @@ var SYSTEM_PROMPTS = [
     description: "Alias for letta",
     content: letta_no_memfs_default,
     memfsContent: letta_default,
+    localMemfsContent: letta_local_memfs_default,
     isDefault: true,
     isFeatured: true
   },
@@ -2471,6 +5448,7 @@ var SYSTEM_PROMPTS = [
     description: "Full Letta Code system prompt",
     content: letta_no_memfs_default,
     memfsContent: letta_default,
+    localMemfsContent: letta_local_memfs_default,
     isFeatured: true
   },
   {
@@ -2497,7 +5475,10 @@ function buildSystemPrompt(presetId, memoryMode) {
   if (!preset) {
     throw new Error(`Unknown preset "${presetId}" — cannot rebuild system prompt`);
   }
-  if (memoryMode === "memfs" || memoryMode === "local-memfs") {
+  if (memoryMode === "local-memfs") {
+    return (preset.localMemfsContent ?? preset.memfsContent ?? preset.content).trim();
+  }
+  if (memoryMode === "memfs") {
     return (preset.memfsContent ?? preset.content).trim();
   }
   return preset.content.trim();
@@ -5987,6 +8968,7 @@ function toSessionDeviceStatus(status) {
     isProcessing: status.is_processing,
     permissionMode,
     workingDirectory: status.current_working_directory,
+    memoryDirectory: typeof status.memory_directory === "string" ? status.memory_directory : null,
     pendingControlRequests: pendingControlRequests(status),
     raw: { ...status }
   };
@@ -6941,7 +9923,7 @@ class RemoteClientSessionCore {
 
 // src/app-server-session.ts
 function agentToolNames(agent) {
-  const tools = agent?.tools;
+  const tools = agent && "tools" in agent ? agent.tools : undefined;
   if (!Array.isArray(tools))
     return;
   return tools.flatMap((tool) => {
@@ -7170,75 +10152,21 @@ function toAppServerApprovalDecision(decision) {
     selected_permission_suggestion_ids: selectedPermissionSuggestionIds
   };
 }
-function stringRecord2(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return;
-  const record = {};
-  for (const [key, entry] of Object.entries(value)) {
-    if (typeof entry === "string")
-      record[key] = entry;
-  }
-  return record;
-}
 function objectRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     return;
   return { ...value };
 }
-function normalizeListModelsResponse(response) {
-  if (!response.success) {
-    throw new Error(response.error ?? "listModels failed");
-  }
-  const entries = Array.isArray(response.entries) ? response.entries.flatMap((entry) => {
-    if (!entry || typeof entry !== "object")
-      return [];
-    const record = entry;
-    if (typeof record.id !== "string" || typeof record.handle !== "string" || typeof record.label !== "string" || typeof record.description !== "string") {
-      return [];
-    }
-    const updateArgs = objectRecord(record.updateArgs);
-    return [
-      {
-        id: record.id,
-        handle: record.handle,
-        label: record.label,
-        description: record.description,
-        ...typeof record.isDefault === "boolean" ? { isDefault: record.isDefault } : {},
-        ...typeof record.isFeatured === "boolean" ? { isFeatured: record.isFeatured } : {},
-        ...typeof record.free === "boolean" ? { free: record.free } : {},
-        ...updateArgs ? { updateArgs } : {}
-      }
-    ];
-  }) : [];
-  const result = { entries };
-  if (response.available_handles === null) {
-    result.availableHandles = null;
-  } else if (Array.isArray(response.available_handles)) {
-    result.availableHandles = response.available_handles.filter((handle) => typeof handle === "string");
-  }
-  const aliases = stringRecord2(response.byok_provider_aliases);
-  if (aliases)
-    result.byokProviderAliases = aliases;
-  return result;
-}
 function normalizeUpdateModelResponse(response) {
   if (!response.success) {
     throw new Error(response.error ?? "Failed to update model");
   }
-  const result = {};
-  if (response.applied_to === "agent" || response.applied_to === "conversation") {
-    result.appliedTo = response.applied_to;
-  }
-  if (typeof response.model_id === "string")
-    result.modelId = response.model_id;
-  if (typeof response.model_handle === "string")
-    result.modelHandle = response.model_handle;
-  if (response.model_settings === null) {
-    result.modelSettings = null;
-  } else if (response.model_settings && typeof response.model_settings === "object") {
-    result.modelSettings = { ...response.model_settings };
-  }
-  return result;
+  return {
+    ...response.applied_to !== undefined ? { appliedTo: response.applied_to } : {},
+    ...response.model_id !== undefined ? { modelId: response.model_id } : {},
+    ...response.model_handle !== undefined ? { modelHandle: response.model_handle } : {},
+    ...response.model_settings !== undefined ? { modelSettings: response.model_settings } : {}
+  };
 }
 function runtimeScopeFromMessage(message) {
   if (message.runtime)
@@ -7323,12 +10251,24 @@ class AppServerRuntimeController {
     await this.client.abort({ runtime });
   }
   request(type, body, options = {}) {
-    const request = this.client.request.bind(this.client);
-    return request(type, body, options);
+    return this.client.requestRaw({
+      type,
+      request_id: this.client.nextRequestId(type),
+      ...body
+    }, {
+      ...options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {},
+      predicate: (message) => {
+        if (!message || typeof message !== "object" || Array.isArray(message)) {
+          return false;
+        }
+        const candidate = message;
+        return typeof candidate.type === "string" && (options.predicate?.(candidate) ?? true);
+      }
+    });
   }
   async listModels() {
     const response = await this.request("list_models", {}, { predicate: (message) => message.type === "list_models_response" });
-    return normalizeListModelsResponse(response);
+    return normalizeAppServerModels(response);
   }
   async updateModel(runtime, payload) {
     const response = await this.request("update_model", {
@@ -7435,7 +10375,7 @@ class AppServerSession extends RemoteClientSessionCore {
         controller: new AppServerRuntimeController(client, this.remoteOptions, this.currentOptions().allowedTools),
         runtime: response.runtime,
         model: typeof response.agent?.model === "string" ? response.agent.model : "",
-        modelSettings: response.agent?.model_settings ?? null,
+        modelSettings: objectRecord(response.agent?.model_settings) ?? null,
         ...tools !== undefined ? { tools } : {},
         ...skillSources !== undefined ? { skillSources: [...skillSources] } : {}
       };
@@ -7470,8 +10410,7 @@ class AppServerSession extends RemoteClientSessionCore {
   }
   async startRuntime(client) {
     const command = await this.buildRuntimeStartCommand(client);
-    const response = await client.runtimeStart(command);
-    return response;
+    return client.runtimeStart(command);
   }
   async buildRuntimeStartCommand(client) {
     const options = this.mode.options;
@@ -7522,8 +10461,13 @@ class AppServerSession extends RemoteClientSessionCore {
     throw new Error("App-server createSession() requires an agent id. Call createAgent() first or pass an agent id.");
   }
   async resolveConversationAgentId(client, conversationId) {
-    const request = client.request.bind(client);
-    const response = await request("conversation_retrieve", { conversation_id: conversationId }, { predicate: (message) => message.type === "conversation_retrieve_response" });
+    const response = await client.request({
+      type: "conversation_retrieve",
+      request_id: client.nextRequestId("conversation_retrieve"),
+      conversation_id: conversationId
+    }, {
+      predicate: (message) => message.type === "conversation_retrieve_response"
+    });
     if (!response.success || !response.conversation?.agent_id) {
       throw new Error(response.error ?? `Failed to retrieve conversation ${conversationId}`);
     }
@@ -7532,87 +10476,21 @@ class AppServerSession extends RemoteClientSessionCore {
 }
 
 // src/cloud-management.ts
-var DEFAULT_CLOUD_API_BASE_URL2 = "https://api.letta.com";
-function defaultApiKey() {
-  const env = globalThis.process?.env;
-  return env?.LETTA_API_KEY ?? env?.LETTA_CLOUD_API_KEY;
-}
-function bearerToken(headers) {
-  const authorization = headers?.Authorization ?? headers?.authorization;
-  return authorization?.match(/^Bearer\s+(.+)$/i)?.[1];
-}
-function apiBaseUrl(value) {
-  const url = new URL(value ?? DEFAULT_CLOUD_API_BASE_URL2);
-  url.pathname = url.pathname.replace(/\/+$/, "");
-  url.search = "";
-  url.hash = "";
-  return url.toString().replace(/\/$/, "");
-}
-function requestHeaders(options) {
-  const headers = {
-    "Content-Type": "application/json",
-    ...options.headers ?? {}
-  };
-  const apiKey = options.apiKey ?? bearerToken(options.headers) ?? defaultApiKey();
-  if (apiKey && !headers.Authorization && !headers.authorization) {
-    headers.Authorization = `Bearer ${apiKey}`;
-  }
-  return headers;
-}
-function appendQuery(url, query) {
-  for (const [key, value] of Object.entries(query)) {
-    if (value === undefined || value === null)
-      continue;
-    if (Array.isArray(value)) {
-      for (const item of value)
-        url.searchParams.append(key, item);
-    } else {
-      url.searchParams.set(key, String(value));
-    }
-  }
-}
-async function parseResponse(response) {
-  const text = await response.text();
-  if (!text)
-    return null;
-  try {
-    return JSON.parse(text);
-  } catch {
-    return text;
-  }
-}
-function responseErrorMessage2(body, fallback) {
-  if (body && typeof body === "object") {
-    const record = body;
-    const message = record.message ?? record.error ?? record.detail;
-    if (typeof message === "string" && message.length > 0)
-      return message;
-  }
-  return fallback;
-}
-function cloudRequestError(response, body, action, url, options) {
-  const parts = [
-    `${action} failed`,
-    responseErrorMessage2(body, `HTTP ${response.status}`),
-    `URL: ${url.toString()}`
-  ];
-  if (response.status === 401 || response.status === 403) {
-    const hasApiKey = Boolean(options.apiKey ?? bearerToken(options.headers) ?? defaultApiKey());
-    parts.push(hasApiKey ? "Authentication failed — the API key may be invalid or lack permissions for this resource." : "No API key found. Set LETTA_API_KEY (or pass apiKey in client options).");
-  }
-  return new Error(parts.join(" — "));
-}
-function asObject(body, action) {
+function asAgentRepository(body, action) {
   if (!body || typeof body !== "object" || Array.isArray(body)) {
-    throw new Error(`${action} response did not include an object.`);
+    throw new Error(`${action} response did not include a repository.`);
   }
-  return body;
-}
-function asArray(body, action) {
-  if (!Array.isArray(body)) {
-    throw new Error(`${action} response did not include an array.`);
+  const repository = body;
+  const permissions = repository.permissions;
+  if (typeof repository.id !== "string" || typeof repository.name !== "string" || typeof repository.is_primary !== "boolean" || permissions !== "read" && permissions !== "read_write") {
+    throw new Error(`${action} response included an invalid repository.`);
   }
-  return body;
+  return {
+    id: repository.id,
+    name: repository.name,
+    isPrimary: repository.is_primary,
+    permissions
+  };
 }
 function cloudModelEntry(raw) {
   if (typeof raw.handle !== "string" || raw.handle.length === 0) {
@@ -7627,26 +10505,62 @@ function cloudModelEntry(raw) {
     description: typeof raw.description === "string" ? raw.description : ""
   };
 }
+function isNotFound(error) {
+  return error instanceof APIError && error.status === 404;
+}
 
 class CloudManagementTransport {
-  options;
-  constructor(options) {
-    this.options = options;
+  client;
+  constructor(client) {
+    this.client = client;
   }
-  listAgents(query) {
-    return this.getArray("/v1/agents/", query, "Cloud list agents");
+  async listAgents(query) {
+    const page = await this.client.agents.list(query);
+    return page.items;
   }
-  retrieveAgent(agentId) {
-    return this.getObject(`/v1/agents/${encodeURIComponent(agentId)}`, {}, "Cloud retrieve agent");
+  async retrieveAgent(agentId) {
+    return this.client.agents.retrieve(agentId);
   }
-  updateAgent(agentId, body) {
-    return this.requestObject(`/v1/agents/${encodeURIComponent(agentId)}`, "PATCH", body, "Cloud update agent");
+  async updateAgent(agentId, body) {
+    return this.client.agents.update(agentId, body);
   }
   async deleteAgent(agentId) {
-    await this.requestUrl(this.url(`/v1/agents/${encodeURIComponent(agentId)}`), "DELETE", undefined, "Cloud delete agent");
+    await this.client.agents.delete(agentId);
+  }
+  async listAgentRepositories(agentId) {
+    const body = await this.client.get(`/v1/agents/${encodeURIComponent(agentId)}/repositories`);
+    if (!Array.isArray(body.repositories)) {
+      throw new Error("Cloud list agent repositories response did not include repositories.");
+    }
+    return body.repositories.map((repository) => asAgentRepository(repository, "Cloud list agent repositories"));
+  }
+  async attachAgentRepository(agentId, repositoryId, permissions) {
+    const body = await this.client.post(`/v1/agents/${encodeURIComponent(agentId)}/repositories`, {
+      body: {
+        repository_id: repositoryId,
+        ...permissions !== undefined ? { permissions } : {}
+      }
+    });
+    return asAgentRepository(body.repository, "Cloud attach agent repository");
+  }
+  async detachAgentRepository(agentId, repositoryId) {
+    try {
+      await this.client.delete(`/v1/agents/${encodeURIComponent(agentId)}/repositories/${encodeURIComponent(repositoryId)}`);
+    } catch (error) {
+      if (!isNotFound(error))
+        throw error;
+    }
+  }
+  async recompileAgentSystemPrompt(agentId) {
+    await this.client.agents.recompile(agentId);
+  }
+  async recompileConversationSystemPrompt(agentId, conversationId) {
+    await this.client.conversations.recompile(conversationId, {
+      agent_id: agentId
+    });
   }
   async listModels() {
-    const entries = await this.getArray("/v1/models", {}, "Cloud list models");
+    const entries = await this.client.models.list();
     const normalized = entries.flatMap((entry) => {
       const model = cloudModelEntry(entry);
       return model ? [model] : [];
@@ -7656,65 +10570,21 @@ class CloudManagementTransport {
       availableHandles: normalized.map((entry) => entry.handle)
     };
   }
-  listConversations(query) {
-    return this.getArray("/v1/conversations/", query, "Cloud list conversations");
+  async listConversations(query) {
+    return this.client.conversations.list(query);
   }
-  retrieveConversation(conversationId) {
-    return this.getObject(`/v1/conversations/${encodeURIComponent(conversationId)}`, {}, "Cloud retrieve conversation");
+  async retrieveConversation(conversationId) {
+    return this.client.conversations.retrieve(conversationId);
   }
-  createConversation(body) {
-    const { agent_id: agentId, ...requestBody } = body;
-    if (typeof agentId !== "string" || agentId.length === 0) {
-      throw new Error("createConversation() requires a non-empty agentId.");
-    }
-    const url = this.url("/v1/conversations/");
-    url.searchParams.set("agent_id", agentId);
-    return this.requestUrlObject(url, "POST", requestBody, "Cloud create conversation");
+  async createConversation(body) {
+    return this.client.conversations.create(body);
   }
-  updateConversation(conversationId, body) {
-    return this.requestObject(`/v1/conversations/${encodeURIComponent(conversationId)}`, "PATCH", body, "Cloud update conversation");
+  async updateConversation(conversationId, body) {
+    return this.client.conversations.update(conversationId, body);
   }
   async listConversationMessages(conversationId, query) {
-    const messages = await this.getArray(`/v1/conversations/${encodeURIComponent(conversationId)}/messages`, query, "Cloud list conversation messages");
-    return { messages };
-  }
-  async getArray(path, query, action) {
-    const body = await this.get(path, query, action);
-    return asArray(body, action);
-  }
-  async getObject(path, query, action) {
-    const body = await this.get(path, query, action);
-    return asObject(body, action);
-  }
-  get(path, query, action) {
-    const url = this.url(path);
-    appendQuery(url, query);
-    return this.requestUrl(url, "GET", undefined, action);
-  }
-  requestObject(path, method, body, action) {
-    return this.requestUrlObject(this.url(path), method, body, action);
-  }
-  async requestUrlObject(url, method, body, action) {
-    return asObject(await this.requestUrl(url, method, body, action), action);
-  }
-  async requestUrl(url, method, body, action) {
-    const fetchImpl = (this.options.fetch ?? globalThis.fetch)?.bind(globalThis);
-    if (!fetchImpl) {
-      throw new Error("No fetch implementation available for cloud backend.");
-    }
-    const response = await fetchImpl(url, {
-      method,
-      headers: requestHeaders(this.options),
-      ...body !== undefined ? { body: JSON.stringify(body) } : {}
-    });
-    const responseBody = await parseResponse(response);
-    if (!response.ok) {
-      throw cloudRequestError(response, responseBody, action, url, this.options);
-    }
-    return responseBody;
-  }
-  url(path) {
-    return new URL(`${apiBaseUrl(this.options.apiBaseUrl)}${path}`);
+    const page = await this.client.conversations.messages.list(conversationId, query);
+    return { messages: page.items };
   }
 }
 
@@ -7935,29 +10805,6 @@ function createCloudStatusTransportConstructor(options) {
 }
 
 // src/remote.ts
-function getDefaultApiKey2() {
-  if (typeof process === "undefined") {
-    return;
-  }
-  return process.env.LETTA_API_KEY;
-}
-function createHeaders(options) {
-  const apiKey = options.apiKey ?? getDefaultApiKey2();
-  return {
-    ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
-    ...options.headers ?? {}
-  };
-}
-function getFetch2(options) {
-  const fetchImpl = options.fetch ?? globalThis.fetch;
-  if (!fetchImpl) {
-    throw new Error("Remote environments require a fetch implementation");
-  }
-  return fetchImpl.bind(globalThis);
-}
-function normalizeBaseUrl2(baseUrl) {
-  return (baseUrl ?? "https://api.letta.com").replace(/\/$/, "");
-}
 function ensureOnline(environment, target) {
   if (!environment.connectionId) {
     const label = "deviceId" in target ? target.deviceId : ("environmentId" in target) ? target.environmentId : ("connectionName" in target) ? target.connectionName : environment.deviceId;
@@ -7969,35 +10816,23 @@ function ensureOnline(environment, target) {
     target
   };
 }
-async function parseJsonResponse2(response) {
-  const text = await response.text();
-  const body = text ? JSON.parse(text) : null;
-  if (!response.ok) {
-    const message = body && typeof body === "object" && "message" in body ? String(body.message) : response.statusText;
-    throw new Error(`Letta API request failed (${response.status}): ${message}`);
-  }
-  return body;
-}
 
 class RemoteEnvironmentClient {
-  options;
-  baseUrl;
-  fetchImpl;
-  constructor(options = {}) {
-    this.options = options;
-    this.baseUrl = normalizeBaseUrl2(options.baseUrl);
-    this.fetchImpl = getFetch2(options);
+  client;
+  constructor(options = {}, client = createCloudClient({
+    backend: "cloud",
+    apiBaseUrl: options.baseUrl,
+    apiKey: options.apiKey,
+    headers: options.headers,
+    fetch: options.fetch
+  })) {
+    this.client = client;
   }
   async listEnvironments() {
-    const url = new URL(`${this.baseUrl}/v1/environments`);
-    const response = await this.fetchImpl(url, {
-      headers: createHeaders(this.options)
-    });
-    return parseJsonResponse2(response);
+    return await this.client.environments.list();
   }
   async getEnvironmentByDeviceId(deviceId) {
-    const response = await this.fetchImpl(`${this.baseUrl}/v1/environments/${encodeURIComponent(deviceId)}`, { headers: createHeaders(this.options) });
-    return parseJsonResponse2(response);
+    return await this.client.environments.retrieve(deviceId);
   }
   async resolveEnvironment(target) {
     if ("connectionId" in target) {
@@ -8035,7 +10870,7 @@ var MAX_TTL_MINUTES = 60;
 var MAX_GITHUB_REPOSITORIES = 10;
 var GITHUB_OWNER_PATTERN = /^[A-Za-z0-9-]+$/;
 var GITHUB_REPOSITORY_PATTERN = /^[A-Za-z0-9._-]+$/;
-function validatePositiveInteger(value, name) {
+function validatePositiveInteger2(value, name) {
   if (value !== undefined && (!Number.isInteger(value) || value <= 0)) {
     throw new Error(`Invalid ${name}. Expected a positive integer.`);
   }
@@ -8049,9 +10884,9 @@ function validateCloudSandboxOptions(options, name) {
   if (options.ttlMinutes !== undefined && (!Number.isInteger(options.ttlMinutes) || options.ttlMinutes < MIN_TTL_MINUTES || options.ttlMinutes > MAX_TTL_MINUTES)) {
     throw new Error(`Invalid ${name}.ttlMinutes. Expected an integer between ${MIN_TTL_MINUTES} and ${MAX_TTL_MINUTES}.`);
   }
-  validatePositiveInteger(options.readyTimeoutMs, `${name}.readyTimeoutMs`);
-  validatePositiveInteger(options.readyPollIntervalMs, `${name}.readyPollIntervalMs`);
-  validatePositiveInteger(options.refreshIntervalMs, `${name}.refreshIntervalMs`);
+  validatePositiveInteger2(options.readyTimeoutMs, `${name}.readyTimeoutMs`);
+  validatePositiveInteger2(options.readyPollIntervalMs, `${name}.readyPollIntervalMs`);
+  validatePositiveInteger2(options.refreshIntervalMs, `${name}.refreshIntervalMs`);
   if (options.githubRepositories !== undefined) {
     if (!Array.isArray(options.githubRepositories)) {
       throw new Error(`Invalid ${name}.githubRepositories. Expected an array.`);
@@ -8077,7 +10912,6 @@ function validateCloudSandboxOptions(options, name) {
 }
 
 // src/cloud-session.ts
-var DEFAULT_CLOUD_API_BASE_URL3 = "https://api.letta.com";
 var DEFAULT_TURN_TIMEOUT_MS = 120000;
 var DEFAULT_PING_INTERVAL_MS = 30000;
 var DEFAULT_SANDBOX_TTL_MINUTES = 5;
@@ -8101,27 +10935,6 @@ class CloudManagedSandboxExpiredError extends Error {
     this.name = "CloudManagedSandboxExpiredError";
   }
 }
-function getDefaultApiKey3() {
-  const env = globalThis.process?.env;
-  return env?.LETTA_API_KEY ?? env?.LETTA_CLOUD_API_KEY;
-}
-function bearerTokenFromHeaders2(headers) {
-  const authorization = headers?.Authorization ?? headers?.authorization;
-  if (!authorization)
-    return;
-  const match = /^Bearer\s+(.+)$/i.exec(authorization);
-  return match?.[1];
-}
-function getCloudApiKey2(options) {
-  return options.apiKey ?? bearerTokenFromHeaders2(options.headers) ?? getDefaultApiKey3();
-}
-function getFetch3(fetchOverride) {
-  const resolved = fetchOverride ?? globalThis.fetch;
-  if (!resolved) {
-    throw new Error("No fetch implementation available for cloud backend.");
-  }
-  return resolved.bind(globalThis);
-}
 function getWebSocketConstructor(websocketOverride) {
   const resolved = websocketOverride ?? globalThis.WebSocket;
   if (!resolved) {
@@ -8129,75 +10942,25 @@ function getWebSocketConstructor(websocketOverride) {
   }
   return resolved;
 }
-function normalizeCloudApiBaseUrl2(url) {
-  const parsed = new URL(url ?? DEFAULT_CLOUD_API_BASE_URL3);
-  parsed.pathname = parsed.pathname.replace(/\/+$/, "");
-  parsed.search = "";
-  parsed.hash = "";
-  return parsed.toString().replace(/\/$/, "");
-}
-function cloudHeaders2(options) {
-  const headers = {
-    "Content-Type": "application/json",
-    ...options.headers ?? {}
-  };
-  const apiKey = getCloudApiKey2(options);
-  if (apiKey && !headers.Authorization && !headers.authorization) {
-    headers.Authorization = `Bearer ${apiKey}`;
-  }
-  return headers;
-}
 function cloudWebSocketHeaders(options) {
   const headers = { ...options.headers ?? {} };
   delete headers.authorization;
   delete headers.Authorization;
-  const apiKey = getCloudApiKey2(options);
+  const apiKey = getCloudApiKey(options);
   if (apiKey)
     headers.Authorization = `Bearer ${apiKey}`;
   return Object.keys(headers).length > 0 ? headers : undefined;
 }
-async function parseJsonResponse3(response) {
-  const text = await response.text();
-  if (!text)
-    return null;
-  try {
-    return JSON.parse(text);
-  } catch {
-    return text;
-  }
-}
-function responseErrorMessage3(body, fallback) {
-  if (body && typeof body === "object") {
-    const record = body;
-    const message = record.message ?? record.error ?? record.detail;
-    const reasonText = record.reason_text;
-    const pieces = [message, reasonText].filter((value) => typeof value === "string" && value.length > 0);
-    if (pieces.length > 0)
-      return pieces.join(": ");
-  }
-  return fallback;
-}
-function assertOkResponse2(response, body, action, url) {
-  if (!response.ok) {
-    const detail = responseErrorMessage3(body, `HTTP ${response.status}`);
-    const parts = [`${action} failed`, detail];
-    if (url)
-      parts.push(`URL: ${url}`);
-    if (response.status === 401 || response.status === 403) {
-      const env = globalThis.process?.env;
-      const hasKey = !!(env?.LETTA_API_KEY ?? env?.LETTA_CLOUD_API_KEY);
-      parts.push(hasKey ? "Authentication failed — the API key may be invalid or lack permissions for this resource." : "No API key found. Set LETTA_API_KEY (or pass apiKey in client options).");
-    }
-    throw new Error(parts.join(" — "));
-  }
+function isNotFound2(error) {
+  return error instanceof APIError && error.status === 404;
 }
-function validatePositiveInteger2(value, name) {
+function validatePositiveInteger3(value, name) {
   if (value !== undefined && (!Number.isInteger(value) || value <= 0)) {
     throw new Error(`Invalid ${name}. Expected a positive integer.`);
   }
 }
 function validateCloudClientOptions(options) {
-  validatePositiveInteger2(options.requestTimeoutMs, "requestTimeoutMs");
+  validatePositiveInteger3(options.requestTimeoutMs, "requestTimeoutMs");
   validateCloudSandboxOptions(options.sandbox, "sandbox");
   if (options.environment !== undefined && options.sandbox !== undefined) {
     throw new Error("Letta Cloud sessions cannot specify both environment and sandbox options.");
@@ -8225,7 +10988,7 @@ function environmentToRemoteTarget(environment) {
   throw new Error("Unknown cloud environment selector.");
 }
 function buildCloudStatusWebSocketUrl(params) {
-  const base = new URL(normalizeCloudApiBaseUrl2(params.apiBaseUrl));
+  const base = new URL(normalizeCloudApiBaseUrl(params.apiBaseUrl));
   if (base.protocol === "http:") {
     base.protocol = "ws:";
   } else if (base.protocol === "https:") {
@@ -8255,7 +11018,7 @@ function isRetryableManagedSandboxResolveError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return message.includes("Remote environment is offline") || message.toLowerCase().includes("not found") || message.includes("(404)");
 }
-function sleep(ms) {
+function sleep3(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function externalToolsByName(tools) {
@@ -8265,20 +11028,13 @@ function externalToolsByName(tools) {
   }
   return result;
 }
-async function createCloudAgent(clientOptions, agentOptions) {
+async function createCloudAgent(client, agentOptions) {
   const body = await createAgentBody(agentOptions);
-  const response = await getFetch3(clientOptions.fetch)(`${normalizeCloudApiBaseUrl2(clientOptions.apiBaseUrl)}/v1/agents`, {
-    method: "POST",
-    headers: cloudHeaders2(clientOptions),
-    body: JSON.stringify(body)
-  });
-  const responseBody = await parseJsonResponse3(response);
-  assertOkResponse2(response, responseBody, "Cloud create agent");
-  const agentId = responseBody && typeof responseBody === "object" ? responseBody.id : undefined;
-  if (typeof agentId !== "string" || agentId.length === 0) {
+  const agent = await client.agents.create(body);
+  if (typeof agent.id !== "string" || agent.id.length === 0) {
     throw new Error("Cloud create agent response did not include an agent id.");
   }
-  return agentId;
+  return agent.id;
 }
 function assertCloudSessionOptionsSupported(action, options) {
   validateCloudSandboxOptions(options.sandbox, "sandbox");
@@ -8289,6 +11045,7 @@ function assertCloudSessionOptionsSupported(action, options) {
 
 class CloudEnvironmentSession extends RemoteClientSessionCore {
   cloudOptions;
+  apiClient;
   connectionId = null;
   removeExternalToolHandler = null;
   removeControlRequestHandler = null;
@@ -8298,22 +11055,29 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
   sandboxRefreshInFlight = null;
   sandboxLifecycleClosing = false;
   attachedRepositoryIds = new Set;
+  repositoryIdsRequiringCleanupRecompile = new Set;
+  repositoryManagement;
   cloudMode;
-  constructor(cloudOptions, mode) {
+  constructor(cloudOptions, mode, apiClient = createCloudClient(cloudOptions)) {
     super(mode, {
       label: "cloud",
       requestTimeoutMs: cloudOptions.requestTimeoutMs ?? DEFAULT_TURN_TIMEOUT_MS
     });
     this.cloudOptions = cloudOptions;
+    this.apiClient = apiClient;
     this.cloudMode = mode;
+    this.repositoryManagement = new CloudManagementTransport(apiClient);
     const tools = mode.options.tools;
     this.externalTools = externalToolsByName(tools);
   }
   async initializeRuntimeController() {
     const resolved = await this.resolveRuntime();
-    const connection = await this.resolveConnectionForRuntime(resolved.runtime);
+    const connection = await this.resolveConnectionForRuntime(resolved.runtime).catch(async (error) => {
+      await this.cleanupSessionRepositories(resolved.runtime.agent_id, resolved.runtime.conversation_id);
+      throw error;
+    });
     this.connectionId = connection.connectionId;
-    const apiKey = getCloudApiKey2(this.cloudOptions);
+    const apiKey = getCloudApiKey(this.cloudOptions);
     const url = buildCloudStatusWebSocketUrl({
       apiBaseUrl: this.cloudOptions.apiBaseUrl,
       connectionId: connection.connectionId,
@@ -8366,7 +11130,7 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
       this.removeControlRequestHandler = null;
       client.close();
       await this.cleanupManagedSandbox();
-      await this.cleanupSessionRepositories(resolved.runtime.agent_id);
+      await this.cleanupSessionRepositories(resolved.runtime.agent_id, resolved.runtime.conversation_id);
       throw error;
     }
   }
@@ -8417,8 +11181,9 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
     this.removeControlRequestHandler?.();
     this.removeControlRequestHandler = null;
     this.cleanupManagedSandbox();
-    if (this.runtime?.agent_id)
-      this.cleanupSessionRepositories(this.runtime.agent_id);
+    if (this.runtime?.agent_id) {
+      this.cleanupSessionRepositories(this.runtime.agent_id, this.runtime.conversation_id);
+    }
   }
   async resolveRuntime() {
     let agentId = this.cloudMode.agentId;
@@ -8433,30 +11198,38 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
     if (!agentId) {
       throw new Error("Letta Cloud createSession()/resumeSession() requires an agent id or conversation id.");
     }
-    await this.attachSessionRepositories(agentId);
-    if (this.cloudMode.newConversation) {
-      const conversation = await this.createConversation(agentId);
-      conversationId = conversation.id;
-    } else if (this.cloudMode.defaultConversation) {
-      conversationId = "default";
-    }
-    if (!conversationId) {
-      throw new Error("Letta Cloud createSession()/resumeSession() requires an agent id or conversation id.");
+    const shouldRecompileRepositories = await this.attachSessionRepositories(agentId);
+    try {
+      if (this.cloudMode.newConversation) {
+        const conversation = await this.createConversation(agentId);
+        conversationId = conversation.id;
+      } else if (this.cloudMode.defaultConversation) {
+        conversationId = "default";
+      }
+      if (!conversationId) {
+        throw new Error("Letta Cloud createSession()/resumeSession() requires an agent id or conversation id.");
+      }
+      if (shouldRecompileRepositories) {
+        await this.recompileSystemPrompt(agentId, conversationId);
+      }
+      return { runtime: { agent_id: agentId, conversation_id: conversationId } };
+    } catch (error) {
+      await this.cleanupSessionRepositories(agentId, conversationId);
+      throw error;
     }
-    return { runtime: { agent_id: agentId, conversation_id: conversationId } };
   }
   async attachSessionRepositories(agentId) {
     const resources = this.repositoryResources();
     if (resources.length === 0)
-      return;
-    const existing = await this.listAgentRepositories(agentId);
+      return false;
+    const existing = await this.repositoryManagement.listAgentRepositories(agentId);
     const existingIds = new Set(existing.map((repository) => repository.id));
     try {
       for (const resource of resources) {
         if (existingIds.has(resource.repositoryId) || this.attachedRepositoryIds.has(resource.repositoryId)) {
           continue;
         }
-        await this.linkAgentRepository(agentId, resource.repositoryId);
+        await this.repositoryManagement.attachAgentRepository(agentId, resource.repositoryId, undefined);
         await this.waitForAgentRepository(agentId, resource.repositoryId);
         this.attachedRepositoryIds.add(resource.repositoryId);
       }
@@ -8464,15 +11237,36 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
       await this.cleanupSessionRepositories(agentId);
       throw error;
     }
+    const shouldRecompile = resources.some((resource) => resource.recompile !== false);
+    this.repositoryIdsRequiringCleanupRecompile = new Set(resources.filter((resource) => resource.recompile !== false && this.attachedRepositoryIds.has(resource.repositoryId)).map((resource) => resource.repositoryId));
+    return shouldRecompile;
   }
-  async cleanupSessionRepositories(agentId) {
+  async cleanupSessionRepositories(agentId, conversationId) {
     const repositoryIds = [...this.attachedRepositoryIds];
+    const repositoryIdsRequiringRecompile = this.repositoryIdsRequiringCleanupRecompile;
     this.attachedRepositoryIds.clear();
-    await Promise.all(repositoryIds.map(async (repositoryId) => {
+    this.repositoryIdsRequiringCleanupRecompile = new Set;
+    const recompileAfterDetach = await Promise.all(repositoryIds.map(async (repositoryId) => {
       try {
-        await this.unlinkAgentRepository(agentId, repositoryId);
-      } catch {}
+        await this.repositoryManagement.detachAgentRepository(agentId, repositoryId);
+        return repositoryIdsRequiringRecompile.has(repositoryId);
+      } catch {
+        return false;
+      }
     }));
+    if (recompileAfterDetach.some(Boolean)) {
+      try {
+        await this.recompileSystemPrompt(agentId, conversationId);
+      } catch {}
+    }
+  }
+  async recompileSystemPrompt(agentId, conversationId) {
+    const usesAgentPrompt = !conversationId || conversationId === "default";
+    if (usesAgentPrompt) {
+      await this.repositoryManagement.recompileAgentSystemPrompt(agentId);
+      return;
+    }
+    await this.repositoryManagement.recompileConversationSystemPrompt(agentId, conversationId);
   }
   repositoryResources() {
     const resources = this.cloudMode.options.resources ?? [];
@@ -8492,76 +11286,33 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
     }
     return result;
   }
-  async listAgentRepositories(agentId) {
-    const fetchImpl = getFetch3(this.cloudOptions.fetch);
-    const baseUrl = normalizeCloudApiBaseUrl2(this.cloudOptions.apiBaseUrl);
-    const response = await fetchImpl(`${baseUrl}/v1/agents/${encodeURIComponent(agentId)}/repositories`, { headers: cloudHeaders2(this.cloudOptions) });
-    const body = await parseJsonResponse3(response);
-    assertOkResponse2(response, body, "Cloud list agent repositories");
-    if (!body || typeof body !== "object")
-      return [];
-    const repositories = body.repositories;
-    return Array.isArray(repositories) ? repositories.filter((repository) => repository !== null && typeof repository === "object" && typeof repository.id === "string") : [];
-  }
   async waitForAgentRepository(agentId, repositoryId) {
     const deadline = Date.now() + DEFAULT_REPOSITORY_ATTACH_TIMEOUT_MS;
     while (true) {
-      const repositories = await this.listAgentRepositories(agentId);
+      const repositories = await this.repositoryManagement.listAgentRepositories(agentId);
       if (repositories.some((repository) => repository.id === repositoryId))
         return;
       if (Date.now() >= deadline) {
         throw new Error(`Cloud attach agent repository did not become visible for ${agentId}: ${repositoryId}`);
       }
-      await sleep(DEFAULT_REPOSITORY_ATTACH_POLL_INTERVAL_MS);
+      await sleep3(DEFAULT_REPOSITORY_ATTACH_POLL_INTERVAL_MS);
     }
   }
-  async linkAgentRepository(agentId, repositoryId) {
-    const fetchImpl = getFetch3(this.cloudOptions.fetch);
-    const baseUrl = normalizeCloudApiBaseUrl2(this.cloudOptions.apiBaseUrl);
-    const response = await fetchImpl(`${baseUrl}/v1/agents/${encodeURIComponent(agentId)}/repositories`, {
-      method: "POST",
-      headers: cloudHeaders2(this.cloudOptions),
-      body: JSON.stringify({ repository_id: repositoryId })
-    });
-    const body = await parseJsonResponse3(response);
-    assertOkResponse2(response, body, "Cloud attach agent repository");
-  }
-  async unlinkAgentRepository(agentId, repositoryId) {
-    const fetchImpl = getFetch3(this.cloudOptions.fetch);
-    const baseUrl = normalizeCloudApiBaseUrl2(this.cloudOptions.apiBaseUrl);
-    const response = await fetchImpl(`${baseUrl}/v1/agents/${encodeURIComponent(agentId)}/repositories/${encodeURIComponent(repositoryId)}`, { method: "DELETE", headers: cloudHeaders2(this.cloudOptions) });
-    const body = await parseJsonResponse3(response);
-    if (response.status === 404)
-      return;
-    assertOkResponse2(response, body, "Cloud detach agent repository");
-  }
   async createConversation(agentId) {
-    const fetchImpl = getFetch3(this.cloudOptions.fetch);
-    const baseUrl = normalizeCloudApiBaseUrl2(this.cloudOptions.apiBaseUrl);
-    const url = new URL(`${baseUrl}/v1/conversations/`);
-    url.searchParams.set("agent_id", agentId);
-    const response = await fetchImpl(url, {
-      method: "POST",
-      headers: cloudHeaders2(this.cloudOptions),
-      body: JSON.stringify({})
+    const conversation = await this.apiClient.conversations.create({
+      agent_id: agentId
     });
-    const body = await parseJsonResponse3(response);
-    assertOkResponse2(response, body, "Cloud createSession()", url.toString());
-    if (!isCloudConversation(body)) {
+    if (!isCloudConversation(conversation)) {
       throw new Error("Cloud createSession() response did not include a conversation id.");
     }
-    return { id: body.id, agent_id: body.agent_id };
+    return { id: conversation.id, agent_id: conversation.agent_id };
   }
   async retrieveConversation(conversationId) {
-    const fetchImpl = getFetch3(this.cloudOptions.fetch);
-    const baseUrl = normalizeCloudApiBaseUrl2(this.cloudOptions.apiBaseUrl);
-    const response = await fetchImpl(`${baseUrl}/v1/conversations/${encodeURIComponent(conversationId)}`, { headers: cloudHeaders2(this.cloudOptions) });
-    const body = await parseJsonResponse3(response);
-    assertOkResponse2(response, body, "Cloud resumeSession()", `${baseUrl}/v1/conversations/${encodeURIComponent(conversationId)}`);
-    if (!isCloudConversation(body)) {
+    const conversation = await this.apiClient.conversations.retrieve(conversationId);
+    if (!isCloudConversation(conversation)) {
       throw new Error(`Cloud resumeSession() could not retrieve conversation ${conversationId}.`);
     }
-    return { id: body.id, agent_id: body.agent_id };
+    return { id: conversation.id, agent_id: conversation.agent_id };
   }
   async resolveConnectionForRuntime(runtime) {
     const environment = this.effectiveEnvironment();
@@ -8598,20 +11349,14 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
     }
   }
   async createManagedSandbox(agentId, conversationId) {
-    const fetchImpl = getFetch3(this.cloudOptions.fetch);
-    const baseUrl = normalizeCloudApiBaseUrl2(this.cloudOptions.apiBaseUrl);
     const sandboxOptions = this.resolvedSandboxOptions();
     const githubRepositories = sandboxOptions.githubRepositories;
-    const response = await fetchImpl(`${baseUrl}/v1/agents/${encodeURIComponent(agentId)}/sandboxes`, {
-      method: "POST",
-      headers: cloudHeaders2(this.cloudOptions),
-      body: JSON.stringify({
+    const body = await this.apiClient.post(`/v1/agents/${encodeURIComponent(agentId)}/sandboxes`, {
+      body: {
         ...conversationId ? { conversationId } : {},
         ...githubRepositories && githubRepositories.length > 0 ? { githubRepositories } : {}
-      })
+      }
     });
-    const body = await parseJsonResponse3(response);
-    assertOkResponse2(response, body, "Cloud create managed sandbox", `${baseUrl}/v1/agents/${encodeURIComponent(agentId)}/sandboxes`);
     if (!isCloudAgentSandbox(body)) {
       throw new Error("Cloud create managed sandbox response did not include sandbox connection details.");
     }
@@ -8649,32 +11394,23 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
     }
   }
   async refreshManagedSandboxOnce(sandbox) {
-    const fetchImpl = getFetch3(this.cloudOptions.fetch);
-    const baseUrl = normalizeCloudApiBaseUrl2(this.cloudOptions.apiBaseUrl);
     if (sandbox.conversationId) {
-      const response2 = await fetchImpl(`${baseUrl}/v1/sandboxes/${encodeURIComponent(sandbox.sandboxId)}/refresh`, {
-        method: "POST",
-        headers: cloudHeaders2(this.cloudOptions),
-        body: JSON.stringify({ ttlMinutes: sandbox.ttlMinutes })
-      });
-      if (response2.status === 404) {
-        await parseJsonResponse3(response2);
+      let body2;
+      try {
+        body2 = await this.apiClient.post(`/v1/sandboxes/${encodeURIComponent(sandbox.sandboxId)}/refresh`, { body: { ttlMinutes: sandbox.ttlMinutes } });
+      } catch (error) {
+        if (!isNotFound2(error))
+          throw error;
         throw new CloudManagedSandboxExpiredError(sandbox.sandboxId, sandbox.conversationId);
       }
-      const body2 = await parseJsonResponse3(response2);
-      assertOkResponse2(response2, body2, "Cloud refresh managed sandbox");
       if (!isCloudAgentSandboxRefresh(body2) || !body2.success) {
         throw new Error("Cloud refresh managed sandbox response did not confirm refresh.");
       }
       return;
     }
-    const response = await fetchImpl(`${baseUrl}/v1/agents/${encodeURIComponent(sandbox.agentId)}/sandboxes/refresh`, {
-      method: "POST",
-      headers: cloudHeaders2(this.cloudOptions),
-      body: JSON.stringify({ ttlMinutes: sandbox.ttlMinutes })
+    const body = await this.apiClient.post(`/v1/agents/${encodeURIComponent(sandbox.agentId)}/sandboxes/refresh`, {
+      body: { ttlMinutes: sandbox.ttlMinutes }
     });
-    const body = await parseJsonResponse3(response);
-    assertOkResponse2(response, body, "Cloud refresh managed sandbox", `${baseUrl}/v1/agents/${encodeURIComponent(sandbox.agentId)}/sandboxes/refresh`);
     if (!isCloudAgentSandboxRefresh(body) || !body.success) {
       throw new Error("Cloud refresh managed sandbox response did not confirm refresh.");
     }
@@ -8683,29 +11419,22 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
     }
   }
   async terminateManagedSandbox(sandbox) {
-    const fetchImpl = getFetch3(this.cloudOptions.fetch);
-    const baseUrl = normalizeCloudApiBaseUrl2(this.cloudOptions.apiBaseUrl);
     if (sandbox.conversationId) {
-      const response2 = await fetchImpl(`${baseUrl}/v1/sandboxes/${encodeURIComponent(sandbox.sandboxId)}/terminate`, {
-        method: "POST",
-        headers: cloudHeaders2(this.cloudOptions),
-        body: JSON.stringify({})
-      });
-      const body2 = await parseJsonResponse3(response2);
-      if (response2.status === 404)
-        return;
-      assertOkResponse2(response2, body2, "Cloud terminate managed sandbox");
+      try {
+        await this.apiClient.post(`/v1/sandboxes/${encodeURIComponent(sandbox.sandboxId)}/terminate`, { body: {} });
+      } catch (error) {
+        if (!isNotFound2(error))
+          throw error;
+      }
       return;
     }
     await this.refreshManagedSandbox(sandbox);
-    const response = await fetchImpl(`${baseUrl}/v1/agents/${encodeURIComponent(sandbox.agentId)}/sandboxes`, {
-      method: "DELETE",
-      headers: cloudHeaders2(this.cloudOptions)
-    });
-    const body = await parseJsonResponse3(response);
-    if (response.status === 404)
-      return;
-    assertOkResponse2(response, body, "Cloud terminate managed sandbox", `${baseUrl}/v1/agents/${encodeURIComponent(sandbox.agentId)}/sandboxes`);
+    try {
+      await this.apiClient.delete(`/v1/agents/${encodeURIComponent(sandbox.agentId)}/sandboxes`);
+    } catch (error) {
+      if (!isNotFound2(error))
+        throw error;
+    }
   }
   async waitForManagedSandboxConnection(sandbox) {
     const deadline = Date.now() + sandbox.readyTimeoutMs;
@@ -8722,7 +11451,7 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
           break;
         }
         const remainingMs = Math.max(0, deadline - Date.now());
-        await sleep(Math.min(sandbox.readyPollIntervalMs, remainingMs));
+        await sleep3(Math.min(sandbox.readyPollIntervalMs, remainingMs));
       }
     }
     const detail = lastError instanceof Error ? lastError.message : String(lastError);
@@ -8760,12 +11489,7 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
     } catch {}
   }
   remoteEnvironmentClient() {
-    return new RemoteEnvironmentClient({
-      baseUrl: this.cloudOptions.apiBaseUrl,
-      apiKey: getCloudApiKey2(this.cloudOptions),
-      headers: this.cloudOptions.headers,
-      fetch: this.cloudOptions.fetch
-    });
+    return new RemoteEnvironmentClient({}, this.apiClient);
   }
   effectiveEnvironment() {
     const modeEnvironment = this.mode.kind === "session" ? this.mode.options.environment : undefined;
@@ -8781,16 +11505,13 @@ class CloudEnvironmentSession extends RemoteClientSessionCore {
 }
 
 // src/management.ts
-function definedEntries(values) {
-  return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== undefined));
-}
-function assertNonEmptyId(value, name) {
+function assertNonEmptyId2(value, name) {
   if (typeof value !== "string" || value.trim().length === 0) {
     throw new Error(`Invalid ${name}. Expected a non-empty string.`);
   }
 }
 function agentListQuery(options) {
-  const orderBy = options.orderBy?.replace(/[A-Z]/g, (character) => `_${character.toLowerCase()}`);
+  const orderBy = options.orderBy === "createdAt" ? "created_at" : options.orderBy === "lastRunCompletion" ? "last_run_completion" : undefined;
   return {
     before: options.before,
     after: options.after,
@@ -8805,7 +11526,7 @@ function agentListQuery(options) {
   };
 }
 function agentUpdateBody(options) {
-  return definedEntries({
+  return {
     name: options.name,
     description: options.description,
     model: options.model,
@@ -8814,10 +11535,10 @@ function agentUpdateBody(options) {
     tags: options.tags,
     hidden: options.hidden,
     context_window_limit: options.contextWindowLimit
-  });
+  };
 }
 function conversationListQuery(options) {
-  const orderBy = options.orderBy?.replace(/[A-Z]/g, (character) => `_${character.toLowerCase()}`);
+  const orderBy = options.orderBy === "createdAt" ? "created_at" : options.orderBy === "lastRunCompletion" ? "last_run_completion" : options.orderBy === "lastMessageAt" ? "last_message_at" : undefined;
   return {
     agent_id: options.agentId,
     after: options.after,
@@ -8829,7 +11550,7 @@ function conversationListQuery(options) {
   };
 }
 function conversationCreateBody(options) {
-  return definedEntries({
+  return {
     agent_id: options.agentId,
     summary: options.summary,
     description: options.description,
@@ -8837,17 +11558,17 @@ function conversationCreateBody(options) {
     model_settings: options.modelSettings,
     context_window_limit: options.contextWindowLimit,
     hidden: options.hidden
-  });
+  };
 }
 function conversationUpdateBody(options) {
-  return definedEntries({
+  return {
     summary: options.summary,
     description: options.description,
     model: options.model,
     model_settings: options.modelSettings,
     context_window_limit: options.contextWindowLimit,
     archived: options.archived
-  });
+  };
 }
 function conversationMessagesQuery(options) {
   return {
@@ -8857,13 +11578,16 @@ function conversationMessagesQuery(options) {
     limit: options.limit
   };
 }
-function createAgentsClient(transport) {
+function createAgentsClient(transport, repositories) {
   return {
+    get repositories() {
+      return repositories();
+    },
     list: (options = {}) => transport().listAgents(agentListQuery(options)),
     retrieve: (agentId) => transport().retrieveAgent(agentId),
     update: (agentId, options) => transport().updateAgent(agentId, agentUpdateBody(options)),
     delete: async (agentId) => {
-      assertNonEmptyId(agentId, "agent id");
+      assertNonEmptyId2(agentId, "agent id");
       await transport().deleteAgent(agentId);
     }
   };
@@ -9058,6 +11782,8 @@ class LettaAgentClientBase {
   models;
   options;
   repositoriesClient = null;
+  agentRepositoriesClient = null;
+  cloudClient = null;
   managementTransport = null;
   constructor(options = {}) {
     const backend = options.backend ?? "local";
@@ -9067,7 +11793,7 @@ class LettaAgentClientBase {
     this.backend = backend;
     this.environment = getOptionsEnvironment(options);
     this.options = options;
-    this.agents = createAgentsClient(() => this.getManagementTransport());
+    this.agents = createAgentsClient(() => this.getManagementTransport(), () => this.getAgentRepositoriesClient());
     this.conversations = createConversationsClient(() => this.getManagementTransport());
     this.models = createModelsClient(() => this.getManagementTransport());
     if (this.backend === "local" && this.environment !== undefined) {
@@ -9123,7 +11849,7 @@ class LettaAgentClientBase {
       return initMsg.agentId;
     }
     if (this.backend === "cloud") {
-      return createCloudAgent(this.cloudOptions(), options);
+      return createCloudAgent(this.getCloudClient(), options);
     }
     return this.createLocalAgent(options);
   }
@@ -9148,7 +11874,7 @@ class LettaAgentClientBase {
         agentId,
         newConversation: true,
         options
-      });
+      }, this.getCloudClient());
     }
     return this.createLocalSession(agentId, options);
   }
@@ -9177,14 +11903,14 @@ class LettaAgentClientBase {
           kind: "session",
           conversationId: id,
           options
-        });
+        }, this.getCloudClient());
       }
       return new CloudEnvironmentSession(this.cloudOptions(), {
         kind: "session",
         agentId: id,
         defaultConversation: true,
         options
-      });
+      }, this.getCloudClient());
     }
     return this.resumeLocalSession(id, options);
   }
@@ -9278,16 +12004,37 @@ class LettaAgentClientBase {
     if (this.backend !== "cloud") {
       throw new Error('client.repositories is only available with backend: "cloud".');
     }
-    this.repositoriesClient ??= new RepositoriesClient(this.cloudOptions());
+    this.repositoriesClient ??= new RepositoriesClient(this.cloudOptions(), this.getCloudClient());
     return this.repositoriesClient;
   }
+  getAgentRepositoriesClient() {
+    if (this.backend !== "cloud") {
+      throw new Error('client.agents.repositories is only available with backend: "cloud".');
+    }
+    this.agentRepositoriesClient ??= createAgentRepositoriesClient(() => this.getCloudManagementTransport());
+    return this.agentRepositoriesClient;
+  }
+  getCloudManagementTransport() {
+    const transport = this.getManagementTransport();
+    if (!(transport instanceof CloudManagementTransport)) {
+      throw new Error("Cloud management requested for non-cloud backend.");
+    }
+    return transport;
+  }
+  getCloudClient() {
+    if (this.backend !== "cloud") {
+      throw new Error("Letta client requested for non-cloud backend.");
+    }
+    this.cloudClient ??= createCloudClient(this.cloudOptions());
+    return this.cloudClient;
+  }
   getManagementTransport() {
     if (this.managementTransport)
       return this.managementTransport;
     if (this.backend === "remote") {
       this.managementTransport = new AppServerManagementTransport(this.remoteOptions());
     } else if (this.backend === "cloud") {
-      this.managementTransport = new CloudManagementTransport(this.cloudOptions());
+      this.managementTransport = new CloudManagementTransport(this.getCloudClient());
     } else {
       this.managementTransport = this.createLocalManagementTransport();
     }
@@ -9388,4 +12135,4 @@ export {
   CloudManagedSandboxExpiredError
 };
 
-//# debugId=AAFE1DD6848E90C364756E2164756E21
+//# debugId=DC9188A459F6634B64756E2164756E21