@letta-ai/letta-client 1.0.0-alpha.6 → 1.0.0

package/src/index.ts

@@ -1,12 +1,13 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-export { LettaSDK as default } from './client';
+export { Letta as default } from './client';
 
 export { type Uploadable, toFile } from './core/uploads';
 export { APIPromise } from './core/api-promise';
-export { LettaSDK, type ClientOptions } from './client';
+export { Letta, type ClientOptions } from './client';
+export { PagePromise } from './core/pagination';
 export {
-  LettaSDKError,
+  LettaError,
   APIError,
   APIConnectionError,
   APIConnectionTimeoutError,

package/src/internal/decoders/line.ts

@@ -0,0 +1,135 @@
+import { concatBytes, decodeUTF8, encodeUTF8 } from '../utils/bytes';
+
+export type Bytes = string | ArrayBuffer | Uint8Array | null | undefined;
+
+/**
+ * A re-implementation of httpx's `LineDecoder` in Python that handles incrementally
+ * reading lines from text.
+ *
+ * https://github.com/encode/httpx/blob/920333ea98118e9cf617f246905d7b202510941c/httpx/_decoders.py#L258
+ */
+export class LineDecoder {
+  // prettier-ignore
+  static NEWLINE_CHARS = new Set(['\n', '\r']);
+  static NEWLINE_REGEXP = /\r\n|[\n\r]/g;
+
+  #buffer: Uint8Array;
+  #carriageReturnIndex: number | null;
+
+  constructor() {
+    this.#buffer = new Uint8Array();
+    this.#carriageReturnIndex = null;
+  }
+
+  decode(chunk: Bytes): string[] {
+    if (chunk == null) {
+      return [];
+    }
+
+    const binaryChunk =
+      chunk instanceof ArrayBuffer ? new Uint8Array(chunk)
+      : typeof chunk === 'string' ? encodeUTF8(chunk)
+      : chunk;
+
+    this.#buffer = concatBytes([this.#buffer, binaryChunk]);
+
+    const lines: string[] = [];
+    let patternIndex;
+    while ((patternIndex = findNewlineIndex(this.#buffer, this.#carriageReturnIndex)) != null) {
+      if (patternIndex.carriage && this.#carriageReturnIndex == null) {
+        // skip until we either get a corresponding `\n`, a new `\r` or nothing
+        this.#carriageReturnIndex = patternIndex.index;
+        continue;
+      }
+
+      // we got double \r or \rtext\n
+      if (
+        this.#carriageReturnIndex != null &&
+        (patternIndex.index !== this.#carriageReturnIndex + 1 || patternIndex.carriage)
+      ) {
+        lines.push(decodeUTF8(this.#buffer.subarray(0, this.#carriageReturnIndex - 1)));
+        this.#buffer = this.#buffer.subarray(this.#carriageReturnIndex);
+        this.#carriageReturnIndex = null;
+        continue;
+      }
+
+      const endIndex =
+        this.#carriageReturnIndex !== null ? patternIndex.preceding - 1 : patternIndex.preceding;
+
+      const line = decodeUTF8(this.#buffer.subarray(0, endIndex));
+      lines.push(line);
+
+      this.#buffer = this.#buffer.subarray(patternIndex.index);
+      this.#carriageReturnIndex = null;
+    }
+
+    return lines;
+  }
+
+  flush(): string[] {
+    if (!this.#buffer.length) {
+      return [];
+    }
+    return this.decode('\n');
+  }
+}
+
+/**
+ * This function searches the buffer for the end patterns, (\r or \n)
+ * and returns an object with the index preceding the matched newline and the
+ * index after the newline char. `null` is returned if no new line is found.
+ *
+ * ```ts
+ * findNewLineIndex('abc\ndef') -> { preceding: 2, index: 3 }
+ * ```
+ */
+function findNewlineIndex(
+  buffer: Uint8Array,
+  startIndex: number | null,
+): { preceding: number; index: number; carriage: boolean } | null {
+  const newline = 0x0a; // \n
+  const carriage = 0x0d; // \r
+
+  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;
+}
+
+export function findDoubleNewlineIndex(buffer: Uint8Array): number {
+  // This function searches the buffer for the end patterns (\r\r, \n\n, \r\n\r\n)
+  // and returns the index right after the first occurrence of any pattern,
+  // or -1 if none of the patterns are found.
+  const newline = 0x0a; // \n
+  const carriage = 0x0d; // \r
+
+  for (let i = 0; i < buffer.length - 1; i++) {
+    if (buffer[i] === newline && buffer[i + 1] === newline) {
+      // \n\n
+      return i + 2;
+    }
+    if (buffer[i] === carriage && buffer[i + 1] === carriage) {
+      // \r\r
+      return i + 2;
+    }
+    if (
+      buffer[i] === carriage &&
+      buffer[i + 1] === newline &&
+      i + 3 < buffer.length &&
+      buffer[i + 2] === carriage &&
+      buffer[i + 3] === newline
+    ) {
+      // \r\n\r\n
+      return i + 4;
+    }
+  }
+
+  return -1;
+}

package/src/internal/parse.ts

@@ -1,7 +1,8 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import type { FinalRequestOptions } from './request-options';
-import { type LettaSDK } from '../client';
+import { Stream } from '../core/streaming';
+import { type Letta } from '../client';
 import { formatRequestDetails, loggerFor } from './utils/log';
 
 export type APIResponseProps = {
@@ -13,9 +14,22 @@ export type APIResponseProps = {
   startTime: number;
 };
 
-export async function defaultParseResponse<T>(client: LettaSDK, props: APIResponseProps): Promise<T> {
+export async function defaultParseResponse<T>(client: Letta, props: APIResponseProps): Promise<T> {
   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);
+
+      // Note: there is an invariant here that isn't represented in the type system
+      // that if you set `stream: true` the response type must also be `Stream<T>`
+
+      if (props.options.__streamClass) {
+        return props.options.__streamClass.fromSSEResponse(response, props.controller, client) as any;
+      }
+
+      return Stream.fromSSEResponse(response, props.controller, client) as any;
+    }
+
     // fetch refuses to read the body when the status code is 204.
     if (response.status === 204) {
       return null as T;

package/src/internal/request-options.ts

@@ -3,6 +3,7 @@
 import { NullableHeaders } from './headers';
 
 import type { BodyInit } from './builtin-types';
+import { Stream } from '../core/streaming';
 import type { HTTPMethod, MergedRequestInit } from './types';
 import { type HeadersLike } from './headers';
 
@@ -76,6 +77,7 @@ export type RequestOptions = {
   defaultBaseURL?: string | undefined;
 
   __binaryResponse?: boolean | undefined;
+  __streamClass?: typeof Stream;
 };
 
 export type EncodedContent = { bodyHeaders: HeadersLike; body: BodyInit };

package/src/internal/shims.ts

@@ -16,7 +16,7 @@ export function getDefaultFetch(): Fetch {
   }
 
   throw new Error(
-    '`fetch` is not defined as a global; Either pass `fetch` to the client, `new LettaSDK({ fetch })` or polyfill the global, `globalThis.fetch = fetch`',
+    '`fetch` is not defined as a global; Either pass `fetch` to the client, `new Letta({ fetch })` or polyfill the global, `globalThis.fetch = fetch`',
   );
 }
 

package/src/internal/uploads.ts

@@ -1,6 +1,6 @@
 import { type RequestOptions } from './request-options';
 import type { FilePropertyBag, Fetch } from './builtin-types';
-import type { LettaSDK } from '../client';
+import type { Letta } from '../client';
 import { ReadableStreamFrom } from './shims';
 
 export type BlobPart = string | ArrayBuffer | ArrayBufferView | Blob | DataView;
@@ -74,7 +74,7 @@ export const isAsyncIterable = (value: any): value is AsyncIterable<any> =>
  */
 export const maybeMultipartFormRequestOptions = async (
   opts: RequestOptions,
-  fetch: LettaSDK | Fetch,
+  fetch: Letta | Fetch,
 ): Promise<RequestOptions> => {
   if (!hasUploadableValue(opts.body)) return opts;
 
@@ -85,7 +85,7 @@ type MultipartFormRequestOptions = Omit<RequestOptions, 'body'> & { body: unknow
 
 export const multipartFormRequestOptions = async (
   opts: MultipartFormRequestOptions,
-  fetch: LettaSDK | Fetch,
+  fetch: Letta | Fetch,
 ): Promise<RequestOptions> => {
   return { ...opts, body: await createForm(opts.body, fetch) };
 };
@@ -98,7 +98,7 @@ const supportsFormDataMap = /* @__PURE__ */ new WeakMap<Fetch, Promise<boolean>>
  * This function detects if the fetch function provided supports the global FormData object to avoid
  * confusing error messages later on.
  */
-function supportsFormData(fetchObject: LettaSDK | Fetch): Promise<boolean> {
+function supportsFormData(fetchObject: Letta | Fetch): Promise<boolean> {
   const fetch: Fetch = typeof fetchObject === 'function' ? fetchObject : (fetchObject as any).fetch;
   const cached = supportsFormDataMap.get(fetch);
   if (cached) return cached;
@@ -124,7 +124,7 @@ function supportsFormData(fetchObject: LettaSDK | Fetch): Promise<boolean> {
 
 export const createForm = async <T = Record<string, unknown>>(
   body: T | undefined,
-  fetch: LettaSDK | Fetch,
+  fetch: Letta | Fetch,
 ): Promise<FormData> => {
   if (!(await supportsFormData(fetch))) {
     throw new TypeError(

package/src/internal/utils/base64.ts

@@ -1,6 +1,6 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { LettaSDKError } from '../../core/error';
+import { LettaError } from '../../core/error';
 import { encodeUTF8 } from './bytes';
 
 export const toBase64 = (data: string | Uint8Array | null | undefined): string => {
@@ -18,7 +18,7 @@ export const toBase64 = (data: string | Uint8Array | null | undefined): string =
     return btoa(String.fromCharCode.apply(null, data as any));
   }
 
-  throw new LettaSDKError('Cannot generate base64 string; Expected `Buffer` or `btoa` to be defined');
+  throw new LettaError('Cannot generate base64 string; Expected `Buffer` or `btoa` to be defined');
 };
 
 export const fromBase64 = (str: string): Uint8Array => {
@@ -36,5 +36,5 @@ export const fromBase64 = (str: string): Uint8Array => {
     return buf;
   }
 
-  throw new LettaSDKError('Cannot decode base64 string; Expected `Buffer` or `atob` to be defined');
+  throw new LettaError('Cannot decode base64 string; Expected `Buffer` or `atob` to be defined');
 };

package/src/internal/utils/log.ts

@@ -1,7 +1,7 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { hasOwn } from './values';
-import { type LettaSDK } from '../../client';
+import { type Letta } from '../../client';
 import { RequestOptions } from '../request-options';
 
 type LogFn = (message: string, ...rest: unknown[]) => void;
@@ -24,7 +24,7 @@ const levelNumbers = {
 export const parseLogLevel = (
   maybeLevel: string | undefined,
   sourceName: string,
-  client: LettaSDK,
+  client: Letta,
 ): LogLevel | undefined => {
   if (!maybeLevel) {
     return undefined;
@@ -60,7 +60,7 @@ const noopLogger = {
 
 let cachedLoggers = /* @__PURE__ */ new WeakMap<Logger, [LogLevel, Logger]>();
 
-export function loggerFor(client: LettaSDK): Logger {
+export function loggerFor(client: Letta): Logger {
   const logger = client.logger;
   const logLevel = client.logLevel ?? 'off';
   if (!logger) {

package/src/internal/utils/path.ts

@@ -1,4 +1,4 @@
-import { LettaSDKError } from '../../core/error';
+import { LettaError } from '../../core/error';
 
 /**
  * Percent-encode everything that isn't safe to have in a path without encoding safe chars.
@@ -72,7 +72,7 @@ export const createPathTagFunction = (pathEncoder = encodeURIPath) =>
         return acc + spaces + arrows;
       }, '');
 
-      throw new LettaSDKError(
+      throw new LettaError(
         `Path parameters result in path with invalid segments:\n${invalidSegments
           .map((e) => e.error)
           .join('\n')}\n${path}\n${underline}`,

package/src/internal/utils/values.ts

@@ -1,6 +1,6 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { LettaSDKError } from '../../core/error';
+import { LettaError } from '../../core/error';
 
 // https://url.spec.whatwg.org/#url-scheme-string
 const startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i;
@@ -39,7 +39,7 @@ export function isObj(obj: unknown): obj is Record<string, unknown> {
 
 export const ensurePresent = <T>(value: T | null | undefined): T => {
   if (value == null) {
-    throw new LettaSDKError(`Expected a value to be given but received ${value} instead.`);
+    throw new LettaError(`Expected a value to be given but received ${value} instead.`);
   }
 
   return value;
@@ -47,10 +47,10 @@ export const ensurePresent = <T>(value: T | null | undefined): T => {
 
 export const validatePositiveInteger = (name: string, n: unknown): number => {
   if (typeof n !== 'number' || !Number.isInteger(n)) {
-    throw new LettaSDKError(`${name} must be an integer`);
+    throw new LettaError(`${name} must be an integer`);
   }
   if (n < 0) {
-    throw new LettaSDKError(`${name} must be a positive integer`);
+    throw new LettaError(`${name} must be a positive integer`);
   }
   return n;
 };
@@ -59,14 +59,14 @@ export const coerceInteger = (value: unknown): number => {
   if (typeof value === 'number') return Math.round(value);
   if (typeof value === 'string') return parseInt(value, 10);
 
-  throw new LettaSDKError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+  throw new LettaError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
 };
 
 export const coerceFloat = (value: unknown): number => {
   if (typeof value === 'number') return value;
   if (typeof value === 'string') return parseFloat(value);
 
-  throw new LettaSDKError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+  throw new LettaError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
 };
 
 export const coerceBoolean = (value: unknown): boolean => {

package/src/pagination.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from ./core/pagination instead */
+export * from './core/pagination';

package/src/resources/access-tokens.ts

@@ -0,0 +1,163 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import { APIPromise } from '../core/api-promise';
+import { RequestOptions } from '../internal/request-options';
+import { path } from '../internal/utils/path';
+
+export class AccessTokens extends APIResource {
+  /**
+   * Create a new client side access token with the specified configuration.
+   */
+  create(body: AccessTokenCreateParams, options?: RequestOptions): APIPromise<AccessTokenCreateResponse> {
+    return this._client.post('/v1/client-side-access-tokens', { body, ...options });
+  }
+
+  /**
+   * List all client side access tokens for the current account. This is only
+   * available for cloud users.
+   */
+  list(
+    query: AccessTokenListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<AccessTokenListResponse> {
+    return this._client.get('/v1/client-side-access-tokens', { query, ...options });
+  }
+
+  /**
+   * Delete a client side access token.
+   */
+  delete(
+    token: string,
+    params: AccessTokenDeleteParams | null | undefined = undefined,
+    options?: RequestOptions,
+  ): APIPromise<unknown> {
+    const { body } = params ?? {};
+    return this._client.delete(path`/v1/client-side-access-tokens/${token}`, { body: body, ...options });
+  }
+}
+
+export interface AccessTokenCreateResponse {
+  token: string;
+
+  expiresAt: string;
+
+  hostname: string;
+
+  policy: AccessTokenCreateResponse.Policy;
+}
+
+export namespace AccessTokenCreateResponse {
+  export interface Policy {
+    data: Array<Policy.Data>;
+
+    version: '1';
+  }
+
+  export namespace Policy {
+    export interface Data {
+      id: string;
+
+      access: Array<'read_messages' | 'write_messages' | 'read_agent' | 'write_agent'>;
+
+      type: 'agent';
+    }
+  }
+}
+
+export interface AccessTokenListResponse {
+  hasNextPage: boolean;
+
+  tokens: Array<AccessTokenListResponse.Token>;
+}
+
+export namespace AccessTokenListResponse {
+  export interface Token {
+    token: string;
+
+    expiresAt: string;
+
+    hostname: string;
+
+    policy: Token.Policy;
+  }
+
+  export namespace Token {
+    export interface Policy {
+      data: Array<Policy.Data>;
+
+      version: '1';
+    }
+
+    export namespace Policy {
+      export interface Data {
+        id: string;
+
+        access: Array<'read_messages' | 'write_messages' | 'read_agent' | 'write_agent'>;
+
+        type: 'agent';
+      }
+    }
+  }
+}
+
+export type AccessTokenDeleteResponse = unknown;
+
+export interface AccessTokenCreateParams {
+  /**
+   * The hostname of the client side application. Please specify the full URL
+   * including the protocol (http or https).
+   */
+  hostname: string;
+
+  policy: Array<AccessTokenCreateParams.Policy>;
+
+  /**
+   * The expiration date of the token. If not provided, the token will expire in 5
+   * minutes
+   */
+  expires_at?: string;
+}
+
+export namespace AccessTokenCreateParams {
+  export interface Policy {
+    id: string;
+
+    access: Array<'read_messages' | 'write_messages' | 'read_agent' | 'write_agent'>;
+
+    type: 'agent';
+  }
+}
+
+export interface AccessTokenListParams {
+  /**
+   * The agent ID to filter tokens by. If provided, only tokens for this agent will
+   * be returned.
+   */
+  agentId?: string;
+
+  /**
+   * The number of tokens to return per page. Defaults to 10.
+   */
+  limit?: number;
+
+  /**
+   * The offset for pagination. Defaults to 0.
+   */
+  offset?: number;
+}
+
+export interface AccessTokenDeleteParams {
+  body?: unknown;
+}
+
+export declare namespace AccessTokens {
+  export {
+    type AccessTokenCreateResponse as AccessTokenCreateResponse,
+    type AccessTokenListResponse as AccessTokenListResponse,
+    type AccessTokenDeleteResponse as AccessTokenDeleteResponse,
+    type AccessTokenCreateParams as AccessTokenCreateParams,
+    type AccessTokenListParams as AccessTokenListParams,
+    type AccessTokenDeleteParams as AccessTokenDeleteParams,
+  };
+}