@letta-ai/letta-client 1.0.0-alpha.2 → 1.0.0-alpha.4

package/Client.d.ts

@@ -8,6 +8,7 @@ import { Tools } from "./api/resources/tools/client/Client";
 import { Sources } from "./api/resources/sources/client/Client";
 import { Folders } from "./api/resources/folders/client/Client";
 import { Agents } from "./api/resources/agents/client/Client";
+import { Chat } from "./api/resources/chat/client/Client";
 import { Groups } from "./api/resources/groups/client/Client";
 import { Identities } from "./api/resources/identities/client/Client";
 import { Models } from "./api/resources/models/client/Client";
@@ -54,6 +55,7 @@ export declare class LettaClient {
     protected _sources: Sources | undefined;
     protected _folders: Folders | undefined;
     protected _agents: Agents | undefined;
+    protected _chat: Chat | undefined;
     protected _groups: Groups | undefined;
     protected _identities: Identities | undefined;
     protected _models: Models | undefined;
@@ -76,6 +78,7 @@ export declare class LettaClient {
     get sources(): Sources;
     get folders(): Folders;
     get agents(): Agents;
+    get chat(): Chat;
     get groups(): Groups;
     get identities(): Identities;
     get models(): Models;

package/Client.js

@@ -9,22 +9,23 @@ const Client_2 = require("./api/resources/tools/client/Client");
 const Client_3 = require("./api/resources/sources/client/Client");
 const Client_4 = require("./api/resources/folders/client/Client");
 const Client_5 = require("./api/resources/agents/client/Client");
-const Client_6 = require("./api/resources/groups/client/Client");
-const Client_7 = require("./api/resources/identities/client/Client");
-const Client_8 = require("./api/resources/models/client/Client");
-const Client_9 = require("./api/resources/blocks/client/Client");
-const Client_10 = require("./api/resources/jobs/client/Client");
-const Client_11 = require("./api/resources/health/client/Client");
-const Client_12 = require("./api/resources/providers/client/Client");
-const Client_13 = require("./api/resources/runs/client/Client");
-const Client_14 = require("./api/resources/steps/client/Client");
-const Client_15 = require("./api/resources/tags/client/Client");
-const Client_16 = require("./api/resources/telemetry/client/Client");
-const Client_17 = require("./api/resources/batches/client/Client");
-const Client_18 = require("./api/resources/voice/client/Client");
-const Client_19 = require("./api/resources/templates/client/Client");
-const Client_20 = require("./api/resources/clientSideAccessTokens/client/Client");
-const Client_21 = require("./api/resources/projects/client/Client");
+const Client_6 = require("./api/resources/chat/client/Client");
+const Client_7 = require("./api/resources/groups/client/Client");
+const Client_8 = require("./api/resources/identities/client/Client");
+const Client_9 = require("./api/resources/models/client/Client");
+const Client_10 = require("./api/resources/blocks/client/Client");
+const Client_11 = require("./api/resources/jobs/client/Client");
+const Client_12 = require("./api/resources/health/client/Client");
+const Client_13 = require("./api/resources/providers/client/Client");
+const Client_14 = require("./api/resources/runs/client/Client");
+const Client_15 = require("./api/resources/steps/client/Client");
+const Client_16 = require("./api/resources/tags/client/Client");
+const Client_17 = require("./api/resources/telemetry/client/Client");
+const Client_18 = require("./api/resources/batches/client/Client");
+const Client_19 = require("./api/resources/voice/client/Client");
+const Client_20 = require("./api/resources/templates/client/Client");
+const Client_21 = require("./api/resources/clientSideAccessTokens/client/Client");
+const Client_22 = require("./api/resources/projects/client/Client");
 class LettaClient {
     constructor(_options = {}) {
         this._options = _options;
@@ -49,69 +50,73 @@ class LettaClient {
         var _a;
         return ((_a = this._agents) !== null && _a !== void 0 ? _a : (this._agents = new Client_5.Agents(this._options)));
     }
+    get chat() {
+        var _a;
+        return ((_a = this._chat) !== null && _a !== void 0 ? _a : (this._chat = new Client_6.Chat(this._options)));
+    }
     get groups() {
         var _a;
-        return ((_a = this._groups) !== null && _a !== void 0 ? _a : (this._groups = new Client_6.Groups(this._options)));
+        return ((_a = this._groups) !== null && _a !== void 0 ? _a : (this._groups = new Client_7.Groups(this._options)));
     }
     get identities() {
         var _a;
-        return ((_a = this._identities) !== null && _a !== void 0 ? _a : (this._identities = new Client_7.Identities(this._options)));
+        return ((_a = this._identities) !== null && _a !== void 0 ? _a : (this._identities = new Client_8.Identities(this._options)));
     }
     get models() {
         var _a;
-        return ((_a = this._models) !== null && _a !== void 0 ? _a : (this._models = new Client_8.Models(this._options)));
+        return ((_a = this._models) !== null && _a !== void 0 ? _a : (this._models = new Client_9.Models(this._options)));
     }
     get blocks() {
         var _a;
-        return ((_a = this._blocks) !== null && _a !== void 0 ? _a : (this._blocks = new Client_9.Blocks(this._options)));
+        return ((_a = this._blocks) !== null && _a !== void 0 ? _a : (this._blocks = new Client_10.Blocks(this._options)));
     }
     get jobs() {
         var _a;
-        return ((_a = this._jobs) !== null && _a !== void 0 ? _a : (this._jobs = new Client_10.Jobs(this._options)));
+        return ((_a = this._jobs) !== null && _a !== void 0 ? _a : (this._jobs = new Client_11.Jobs(this._options)));
     }
     get health() {
         var _a;
-        return ((_a = this._health) !== null && _a !== void 0 ? _a : (this._health = new Client_11.Health(this._options)));
+        return ((_a = this._health) !== null && _a !== void 0 ? _a : (this._health = new Client_12.Health(this._options)));
     }
     get providers() {
         var _a;
-        return ((_a = this._providers) !== null && _a !== void 0 ? _a : (this._providers = new Client_12.Providers(this._options)));
+        return ((_a = this._providers) !== null && _a !== void 0 ? _a : (this._providers = new Client_13.Providers(this._options)));
     }
     get runs() {
         var _a;
-        return ((_a = this._runs) !== null && _a !== void 0 ? _a : (this._runs = new Client_13.Runs(this._options)));
+        return ((_a = this._runs) !== null && _a !== void 0 ? _a : (this._runs = new Client_14.Runs(this._options)));
     }
     get steps() {
         var _a;
-        return ((_a = this._steps) !== null && _a !== void 0 ? _a : (this._steps = new Client_14.Steps(this._options)));
+        return ((_a = this._steps) !== null && _a !== void 0 ? _a : (this._steps = new Client_15.Steps(this._options)));
     }
     get tags() {
         var _a;
-        return ((_a = this._tags) !== null && _a !== void 0 ? _a : (this._tags = new Client_15.Tags(this._options)));
+        return ((_a = this._tags) !== null && _a !== void 0 ? _a : (this._tags = new Client_16.Tags(this._options)));
     }
     get telemetry() {
         var _a;
-        return ((_a = this._telemetry) !== null && _a !== void 0 ? _a : (this._telemetry = new Client_16.Telemetry(this._options)));
+        return ((_a = this._telemetry) !== null && _a !== void 0 ? _a : (this._telemetry = new Client_17.Telemetry(this._options)));
     }
     get batches() {
         var _a;
-        return ((_a = this._batches) !== null && _a !== void 0 ? _a : (this._batches = new Client_17.Batches(this._options)));
+        return ((_a = this._batches) !== null && _a !== void 0 ? _a : (this._batches = new Client_18.Batches(this._options)));
     }
     get voice() {
         var _a;
-        return ((_a = this._voice) !== null && _a !== void 0 ? _a : (this._voice = new Client_18.Voice(this._options)));
+        return ((_a = this._voice) !== null && _a !== void 0 ? _a : (this._voice = new Client_19.Voice(this._options)));
     }
     get templates() {
         var _a;
-        return ((_a = this._templates) !== null && _a !== void 0 ? _a : (this._templates = new Client_19.Templates(this._options)));
+        return ((_a = this._templates) !== null && _a !== void 0 ? _a : (this._templates = new Client_20.Templates(this._options)));
     }
     get clientSideAccessTokens() {
         var _a;
-        return ((_a = this._clientSideAccessTokens) !== null && _a !== void 0 ? _a : (this._clientSideAccessTokens = new Client_20.ClientSideAccessTokens(this._options)));
+        return ((_a = this._clientSideAccessTokens) !== null && _a !== void 0 ? _a : (this._clientSideAccessTokens = new Client_21.ClientSideAccessTokens(this._options)));
     }
     get projects() {
         var _a;
-        return ((_a = this._projects) !== null && _a !== void 0 ? _a : (this._projects = new Client_21.Projects(this._options)));
+        return ((_a = this._projects) !== null && _a !== void 0 ? _a : (this._projects = new Client_22.Projects(this._options)));
     }
 }
 exports.LettaClient = LettaClient;

package/README.md

@@ -1,139 +1,369 @@
-# Letta TypeScript Library
+# Letta TypeScript SDK
 
-[![fern shield](https://img.shields.io/badge/%F0%9F%8C%BF-Built%20with%20Fern-brightgreen)](https://buildwithfern.com?utm_source=github&utm_medium=github&utm_campaign=readme&utm_source=https%3A%2F%2Fgithub.com%2Fletta-ai%2Fletta-node)
 [![npm shield](https://img.shields.io/npm/v/@letta-ai/letta-client)](https://www.npmjs.com/package/@letta-ai/letta-client)
 
-The Letta TypeScript library provides convenient access to the Letta APIs from TypeScript.
+Letta is the platform for building stateful agents: open AI with advanced memory that can learn and self-improve over time.
 
-## Installation
+### Quicklinks:
+* [**Developer Documentation**](https://docs.letta.com): Learn how to create agents using Python or TypeScript
+* [**TypeScript API Reference**](./reference.md): Complete TypeScript SDK documentation
+* [**Agent Development Environment (ADE)**](https://docs.letta.com/guides/ade/overview): A no-code UI for building stateful agents
+* [**Letta Cloud**](https://app.letta.com/): The fastest way to try Letta
 
-```sh
-npm i -s @letta-ai/letta-client
+## Get started
+
+Install the Letta TypeScript SDK:
+
+```bash
+npm install @letta-ai/letta-client
+```
+
+## Simple Hello World example
+
+In the example below, we'll create a stateful agent with two memory blocks. We'll initialize the `human` memory block with incorrect information, and correct the agent in our first message - which will trigger the agent to update its own memory with a tool call.
+
+*To run the examples, you'll need to get a `LETTA_API_KEY` from [Letta Cloud](https://app.letta.com/api-keys), or run your own self-hosted server (see [our guide](https://docs.letta.com/guides/selfhosting))*
+
+```typescript
+import { LettaClient } from '@letta-ai/letta-client';
+
+const client = new LettaClient({ token: "LETTA_API_KEY" });
+// const client = new LettaClient({ baseUrl: "http://localhost:8283" });  // if self-hosting
+
+const agentState = await client.agents.create({
+    model: "openai/gpt-4o-mini",
+    embedding: "openai/text-embedding-3-small",
+    memoryBlocks: [
+        {
+          label: "human",
+          value: "The human's name is Chad. They like vibe coding."
+        },
+        {
+          label: "persona",
+          value: "My name is Sam, a helpful assistant."
+        }
+    ],
+    tools: ["web_search", "run_code"]
+});
+
+console.log(agentState.id);
+// agent-d9be...0846
+
+const response = await client.agents.messages.create(agentState.id, {
+    messages: [
+        {
+            role: "user",
+            content: "Hey, nice to meet you, my name is Brad."
+        }
+    ]
+});
+
+// the agent will think, then edit its memory using a tool
+for (const message of response.messages) {
+    console.log(message);
+}
+
+// The content of this memory block will be something like
+// "The human's name is Brad. They like vibe coding."
+// Fetch this block's content with:
+const human_block = await client.agents.blocks.retrieve(agentState.id, "human");
+console.log(human_block.value);
 ```
 
-## Reference
+## Core concepts in Letta:
 
-A full reference for this library is available [here](https://github.com/letta-ai/letta-node/blob/HEAD/./reference.md).
+Letta is built on the [MemGPT](https://arxiv.org/abs/2310.08560) research paper, which introduced the concept of the "LLM Operating System" for memory management:
 
-## Usage
+1. [**Memory Hierarchy**](https://docs.letta.com/guides/agents/memory): Agents have self-editing memory split between in-context and out-of-context memory
+2. [**Memory Blocks**](https://docs.letta.com/guides/agents/memory-blocks): In-context memory is composed of persistent editable blocks
+3. [**Agentic Context Engineering**](https://docs.letta.com/guides/agents/context-engineering): Agents control their context window using tools to edit, delete, or search memory
+4. [**Perpetual Self-Improving Agents**](https://docs.letta.com/guides/agents/overview): Every agent has a perpetual (infinite) message history
 
-Instantiate and use the client with the following:
+## Local Development
+
+Connect to a local Letta server instead of the cloud:
 
 ```typescript
-import { LettaClient } from "@letta-ai/letta-client";
+const client = new LettaClient({
+  baseUrl: "http://localhost:8283"
+});
+```
+
+Run Letta locally with Docker:
+
+```bash
+docker run \
+  -v ~/.letta/.persist/pgdata:/var/lib/postgresql/data \
+  -p 8283:8283 \
+  -e OPENAI_API_KEY="your_key" \
+  letta/letta:latest
+```
+
+See the [self-hosting guide](https://docs.letta.com/guides/selfhosting) for more options.
 
-const client = new LettaClient({ token: "YOUR_TOKEN", project: "YOUR_PROJECT" });
-await client.archives.createArchive({
-    name: "name",
+## Key Features
+
+### Memory Management ([full guide](https://docs.letta.com/guides/agents/memory-blocks))
+
+Memory blocks are persistent, editable sections of an agent's context window:
+
+```typescript
+// Create agent with memory blocks
+const agent = await client.agents.create({
+  memoryBlocks: [
+    { label: "persona", value: "I'm a helpful assistant." },
+    { label: "human", value: "User preferences and info." }
+  ]
 });
+
+// Modify blocks manually
+await client.agents.blocks.modify(agent.id, "human", {
+  value: "Updated user information"
+});
+
+// Retrieve a block
+const block = await client.agents.blocks.retrieve(agent.id, "human");
 ```
 
-## Request And Response Types
+### Multi-agent Shared Memory ([full guide](https://docs.letta.com/guides/agents/multi-agent-shared-memory))
 
-The SDK exports all request and response types as TypeScript interfaces. Simply import them with the
-following namespace:
+Memory blocks can be attached to multiple agents. All agents will have an up-to-date view on the contents of the memory block -- if one agent modifies it, the other will see it immediately.
+
+Here is how to attach a single memory block to multiple agents:
 
 ```typescript
-import { Letta } from "@letta-ai/letta-client";
+// Create shared block
+const sharedBlock = await client.blocks.create({
+  label: "organization",
+  value: "Shared team context"
+});
 
-const request: Letta.ListArchivesRequest = {
-    ...
-};
+// Attach to multiple agents
+const agent1 = await client.agents.create({
+  memoryBlocks: [{ label: "persona", value: "I am a supervisor" }],
+  blockIds: [sharedBlock.id]
+});
+
+const agent2 = await client.agents.create({
+  memoryBlocks: [{ label: "persona", value: "I am a worker" }],
+  blockIds: [sharedBlock.id]
+});
 ```
 
-## Exception Handling
+### Sleep-time Agents ([full guide](https://docs.letta.com/guides/agents/architectures/sleeptime))
 
-When the API returns a non-success status code (4xx or 5xx response), a subclass of the following error
-will be thrown.
+Background agents that share memory with your primary agent:
 
 ```typescript
-import { LettaError } from "@letta-ai/letta-client";
+const agent = await client.agents.create({
+  model: "openai/gpt-4o-mini",
+  enableSleeptime: true  // creates a sleep-time agent
+});
+```
 
-try {
-    await client.archives.createArchive(...);
-} catch (err) {
-    if (err instanceof LettaError) {
-        console.log(err.statusCode);
-        console.log(err.message);
-        console.log(err.body);
-        console.log(err.rawResponse);
-    }
-}
+### Agent File Import/Export ([full guide](https://docs.letta.com/guides/agents/agent-file))
+
+Save and share agents with the `.af` file format:
+
+```typescript
+import { readFileSync } from 'fs';
+
+// Import agent
+const file = new Blob([readFileSync('/path/to/agent.af')]);
+const agent = await client.agents.importAgentSerialized(file);
+
+// Export agent
+const schema = await client.agents.exportAgentSerialized(agent.id);
 ```
 
-## Advanced
+### MCP Tools ([full guide](https://docs.letta.com/guides/mcp/overview))
+
+Connect to Model Context Protocol servers:
+
+```typescript
+// Add tool from MCP server
+const tool = await client.tools.addMcpTool("weather-server", "get_weather");
+
+// Create agent with MCP tool
+const agent = await client.agents.create({
+  model: "openai/gpt-4o-mini",
+  toolIds: [tool.id]
+});
+```
 
-### Additional Headers
+### Filesystem ([full guide](https://docs.letta.com/guides/agents/filesystem))
 
-If you would like to send additional headers as part of the request, use the `headers` request option.
+Give agents access to files:
 
 ```typescript
-const response = await client.archives.createArchive(..., {
-    headers: {
-        'X-Custom-Header': 'custom value'
-    }
+import { createReadStream } from 'fs';
+
+// Get an available embedding config
+const embeddingConfigs = await client.embeddingModels.list();
+
+// Create folder and upload file
+const folder = await client.folders.create({
+  name: "my_folder",
+  embeddingConfig: embeddingConfigs[0]
 });
+await client.folders.files.upload(createReadStream("file.txt"), folder.id);
+
+// Attach to agent
+await client.agents.folders.attach(agent.id, folder.id);
 ```
 
-### Retries
+### Long-running Agents ([full guide](https://docs.letta.com/guides/agents/long-running))
+
+Background execution with resumable streaming:
 
-The SDK is instrumented with automatic retries with exponential backoff. A request will be retried as long
-as the request is deemed retryable and the number of retry attempts has not grown larger than the configured
-retry limit (default: 2).
+```typescript
+const stream = await client.agents.messages.createStream(agent.id, {
+  messages: [{ role: "user", content: "Analyze this dataset" }],
+  background: true
+});
+
+let runId, lastSeqId;
+for await (const chunk of stream) {
+  runId = chunk.runId;
+  lastSeqId = chunk.seqId;
+}
 
-A request is deemed retryable when any of the following HTTP status codes is returned:
+// Resume if disconnected
+for await (const chunk of client.runs.stream(runId, { startingAfter: lastSeqId })) {
+  console.log(chunk);
+}
+```
 
-- [408](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/408) (Timeout)
-- [429](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/429) (Too Many Requests)
-- [5XX](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/500) (Internal Server Errors)
+### Streaming ([full guide](https://docs.letta.com/guides/agents/streaming))
 
-Use the `maxRetries` request option to configure this behavior.
+Stream responses in real-time:
 
 ```typescript
-const response = await client.archives.createArchive(..., {
-    maxRetries: 0 // override maxRetries at the request level
+const stream = await client.agents.messages.createStream(agent.id, {
+  messages: [{ role: "user", content: "Hello!" }]
 });
+
+for await (const chunk of stream) {
+  console.log(chunk);
+}
 ```
 
-### Timeouts
+### Message Types ([full guide](https://docs.letta.com/guides/agents/message-types))
+
+Agent responses contain different message types. Handle them with the `messageType` discriminator:
+
+```typescript
+const messages = await client.agents.messages.list(agent.id);
+
+for (const message of messages) {
+  switch (message.messageType) {
+    case "user_message":
+      console.log("User:", message.content);
+      break;
+    case "assistant_message":
+      console.log("Agent:", message.content);
+      break;
+    case "reasoning_message":
+      console.log("Reasoning:", message.reasoning);
+      break;
+    case "tool_call_message":
+      console.log("Tool:", message.toolCall.name);
+      break;
+    case "tool_return_message":
+      console.log("Result:", message.toolReturn);
+      break;
+  }
+}
+```
+
+## TypeScript Support
 
-The SDK defaults to a 60 second timeout. Use the `timeoutInSeconds` option to configure this behavior.
+Full TypeScript support with exported types:
 
 ```typescript
-const response = await client.archives.createArchive(..., {
-    timeoutInSeconds: 30 // override timeout to 30s
+import { Letta } from "@letta-ai/letta-client";
+
+const request: Letta.CreateAgentRequest = {
+  model: "openai/gpt-4o-mini",
+  memoryBlocks: [...]
+};
+```
+
+## Error Handling
+
+```typescript
+import { LettaError } from "@letta-ai/letta-client";
+
+try {
+  await client.agents.messages.create(agentId, {...});
+} catch (err) {
+  if (err instanceof LettaError) {
+    console.log(err.statusCode);
+    console.log(err.message);
+    console.log(err.body);
+  }
+}
+```
+
+## Advanced Configuration
+
+### Retries
+
+```typescript
+const response = await client.agents.create({...}, {
+  maxRetries: 3 // Default: 2
 });
 ```
 
-### Aborting Requests
+### Timeouts
+
+```typescript
+const response = await client.agents.create({...}, {
+  timeoutInSeconds: 30 // Default: 60
+});
+```
 
-The SDK allows users to abort requests at any point by passing in an abort signal.
+### Custom Headers
 
 ```typescript
-const controller = new AbortController();
-const response = await client.archives.createArchive(..., {
-    abortSignal: controller.signal
+const response = await client.agents.create({...}, {
+  headers: {
+    'X-Custom-Header': 'value'
+  }
 });
-controller.abort(); // aborts the request
 ```
 
-### Access Raw Response Data
+### Abort Requests
 
-The SDK provides access to raw response data, including headers, through the `.withRawResponse()` method.
-The `.withRawResponse()` method returns a promise that results to an object with a `data` and a `rawResponse` property.
+```typescript
+const controller = new AbortController();
+const response = await client.agents.create({...}, {
+  abortSignal: controller.signal
+});
+controller.abort();
+```
+
+### Raw Response Access
 
 ```typescript
-const { data, rawResponse } = await client.archives.createArchive(...).withRawResponse();
+const { data, rawResponse } = await client.agents
+  .create({...})
+  .withRawResponse();
 
-console.log(data);
 console.log(rawResponse.headers['X-My-Header']);
 ```
 
-### Runtime Compatibility
+### Custom Fetch Client
 
-The SDK defaults to `node-fetch` but will use the global fetch client if present. The SDK works in the following
-runtimes:
+```typescript
+const client = new LettaClient({
+  fetcher: yourCustomFetchImplementation
+});
+```
+
+## Runtime Compatibility
 
+Works in:
 - Node.js 18+
 - Vercel
 - Cloudflare Workers
@@ -141,26 +371,28 @@ runtimes:
 - Bun 1.0+
 - React Native
 
-### Customizing Fetch Client
+## Contributing
 
-The SDK provides a way for you to customize the underlying HTTP client / Fetch function. If you're running in an
-unsupported environment, this provides a way for you to break glass and ensure the SDK works.
+Letta is an open source project built by over a hundred contributors. There are many ways to get involved in the Letta OSS project!
 
-```typescript
-import { LettaClient } from "@letta-ai/letta-client";
+* [**Join the Discord**](https://discord.gg/letta): Chat with the Letta devs and other AI developers.
+* [**Chat on our forum**](https://forum.letta.com/): If you're not into Discord, check out our developer forum.
+* **Follow our socials**: [Twitter/X](https://twitter.com/Letta_AI), [LinkedIn](https://www.linkedin.com/company/letta-ai/), [YouTube](https://www.youtube.com/@letta-ai)
 
-const client = new LettaClient({
-    ...
-    fetcher: // provide your implementation here
-});
-```
+This SDK is generated programmatically. For SDK changes, please [open an issue](https://github.com/letta-ai/letta-node/issues).
 
-## Contributing
+README contributions are always welcome!
+
+## Resources
+
+- [Documentation](https://docs.letta.com)
+- [TypeScript API Reference](./reference.md)
+- [Example Applications](https://github.com/letta-ai/letta-chatbot-example)
+
+## License
+
+MIT
 
-While we value open-source contributions to this SDK, this library is generated programmatically.
-Additions made directly to this library would have to be moved over to our generation code,
-otherwise they would be overwritten upon the next generated release. Feel free to open a PR as
-a proof of concept, but know that we will not be able to merge it as-is. We suggest opening
-an issue first to discuss with us!
+---
 
-On the other hand, contributions to the README are always very welcome!
+***Legal notices**: By using Letta and related Letta services (such as the Letta endpoint or hosted service), you are agreeing to our [privacy policy](https://www.letta.com/privacy-policy) and [terms of service](https://www.letta.com/terms-of-service).*

package/api/errors/GoneError.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as errors from "../../errors/index";
+import * as core from "../../core";
+export declare class GoneError extends errors.LettaError {
+    constructor(body?: unknown, rawResponse?: core.RawResponse);
+}