@stack0/sdk 0.5.7 → 0.5.9

package/dist/index.mjs

@@ -959,6 +959,27 @@ var CDN = class {
     }
     return this.confirmUpload(assetId);
   }
+  /**
+   * Upload a file from a remote URL (server-side fetch).
+   * The server streams the file directly from the source URL into storage,
+   * so the client never touches the bytes. Ideal for serverless environments
+   * with tight memory limits.
+   *
+   * @example
+   * ```typescript
+   * const asset = await cdn.uploadFromUrl({
+   *   projectSlug: 'my-project',
+   *   sourceUrl: 'https://replicate.delivery/output/video.mp4',
+   *   filename: 'video.mp4',
+   *   mimeType: 'video/mp4',
+   * });
+   * console.log(asset.cdnUrl);
+   * ```
+   */
+  async uploadFromUrl(request) {
+    const response = await this.http.post("/cdn/upload-from-url", request);
+    return this.convertAssetDates(response);
+  }
   /**
    * Get an asset by ID
    *
@@ -1335,6 +1356,80 @@ var CDN = class {
   async extractAudio(request) {
     return this.http.post("/cdn/video/extract-audio", request);
   }
+  // ============================================================================
+  // GIF Generation Methods
+  // ============================================================================
+  /**
+   * Generate an animated GIF from a video segment
+   *
+   * Creates an optimized GIF from a portion of the video. Uses two-pass
+   * palette generation by default for smaller file sizes with better quality.
+   *
+   * @example
+   * ```typescript
+   * const gif = await cdn.generateGif({
+   *   projectSlug: 'my-project',
+   *   assetId: 'video-asset-id',
+   *   startTime: 5,      // Start at 5 seconds
+   *   duration: 3,       // 3 second GIF
+   *   width: 480,        // 480px wide
+   *   fps: 10,           // 10 frames per second
+   * });
+   *
+   * // Poll for completion
+   * let result = await cdn.getGif(gif.id);
+   * while (result?.status === 'pending' || result?.status === 'processing') {
+   *   await new Promise(r => setTimeout(r, 1000));
+   *   result = await cdn.getGif(gif.id);
+   * }
+   *
+   * console.log(`GIF URL: ${result?.url}`);
+   * ```
+   */
+  async generateGif(request) {
+    const response = await this.http.post("/cdn/video/gif", request);
+    return this.convertGifDates(response);
+  }
+  /**
+   * Get a specific GIF by ID
+   *
+   * @example
+   * ```typescript
+   * const gif = await cdn.getGif('gif-id');
+   * if (gif?.status === 'completed') {
+   *   console.log(`GIF URL: ${gif.url}`);
+   *   console.log(`Size: ${gif.sizeBytes} bytes`);
+   * }
+   * ```
+   */
+  async getGif(gifId) {
+    const response = await this.http.get(`/cdn/video/gif/${gifId}`);
+    return response ? this.convertGifDates(response) : null;
+  }
+  /**
+   * List all GIFs generated for a video asset
+   *
+   * @example
+   * ```typescript
+   * const gifs = await cdn.listGifs({ assetId: 'video-asset-id' });
+   * for (const gif of gifs) {
+   *   console.log(`GIF at ${gif.startTime}s: ${gif.url}`);
+   * }
+   * ```
+   */
+  async listGifs(request) {
+    const response = await this.http.get(`/cdn/video/${request.assetId}/gifs`);
+    return response.map((gif) => this.convertGifDates(gif));
+  }
+  convertGifDates(gif) {
+    if (typeof gif.createdAt === "string") {
+      gif.createdAt = new Date(gif.createdAt);
+    }
+    if (gif.completedAt && typeof gif.completedAt === "string") {
+      gif.completedAt = new Date(gif.completedAt);
+    }
+    return gif;
+  }
   convertJobDates(job) {
     if (typeof job.createdAt === "string") {
       job.createdAt = new Date(job.createdAt);
@@ -1937,6 +2032,204 @@ var CDN = class {
   convertMergeJobWithOutputDates(job) {
     return this.convertMergeJobDates(job);
   }
+  // ============================================================================
+  // S3 Import Methods
+  // ============================================================================
+  /**
+   * Create an S3 import job to bulk import files from an external S3 bucket.
+   * Requires Pro plan or higher.
+   *
+   * @example
+   * ```typescript
+   * // Using IAM credentials
+   * const job = await cdn.createImport({
+   *   projectSlug: 'my-project',
+   *   sourceBucket: 'my-external-bucket',
+   *   sourceRegion: 'us-east-1',
+   *   sourcePrefix: 'images/',
+   *   authType: 'iam_credentials',
+   *   accessKeyId: 'AKIA...',
+   *   secretAccessKey: 'secret...',
+   *   pathMode: 'flatten',
+   *   notifyEmail: 'admin@example.com',
+   * });
+   *
+   * // Using role assumption
+   * const job = await cdn.createImport({
+   *   projectSlug: 'my-project',
+   *   sourceBucket: 'partner-bucket',
+   *   sourceRegion: 'eu-west-1',
+   *   authType: 'role_assumption',
+   *   roleArn: 'arn:aws:iam::123456789012:role/Stack0ImportRole',
+   *   externalId: 'optional-external-id',
+   *   pathMode: 'preserve',
+   *   targetFolder: '/imported',
+   * });
+   *
+   * console.log(`Import job started: ${job.importId}`);
+   * ```
+   */
+  async createImport(request) {
+    const response = await this.http.post("/cdn/imports", request);
+    return this.convertCreateImportDates(response);
+  }
+  /**
+   * Get an import job by ID
+   *
+   * @example
+   * ```typescript
+   * const job = await cdn.getImport('import-id');
+   * console.log(`Status: ${job.status}`);
+   * console.log(`Progress: ${job.processedFiles}/${job.totalFiles} files`);
+   * console.log(`Bytes: ${job.processedBytes}/${job.totalBytes}`);
+   * ```
+   */
+  async getImport(importId) {
+    const response = await this.http.get(`/cdn/imports/${importId}`);
+    return response ? this.convertImportJobDates(response) : null;
+  }
+  /**
+   * List import jobs with pagination and filters
+   *
+   * @example
+   * ```typescript
+   * const { imports, total, hasMore } = await cdn.listImports({
+   *   projectSlug: 'my-project',
+   *   status: 'importing',
+   *   limit: 20,
+   * });
+   *
+   * for (const job of imports) {
+   *   console.log(`${job.sourceBucket}: ${job.processedFiles}/${job.totalFiles}`);
+   * }
+   * ```
+   */
+  async listImports(request) {
+    const params = new URLSearchParams();
+    params.set("projectSlug", request.projectSlug);
+    if (request.environment) params.set("environment", request.environment);
+    if (request.status) params.set("status", request.status);
+    if (request.sortBy) params.set("sortBy", request.sortBy);
+    if (request.sortOrder) params.set("sortOrder", request.sortOrder);
+    if (request.limit) params.set("limit", request.limit.toString());
+    if (request.offset) params.set("offset", request.offset.toString());
+    const response = await this.http.get(`/cdn/imports?${params.toString()}`);
+    return {
+      ...response,
+      imports: response.imports.map((job) => this.convertImportJobSummaryDates(job))
+    };
+  }
+  /**
+   * Cancel a running import job
+   *
+   * Files already imported will remain. Only pending/validating/importing jobs can be cancelled.
+   *
+   * @example
+   * ```typescript
+   * const result = await cdn.cancelImport('import-id');
+   * console.log(`Cancelled: ${result.success}`);
+   * ```
+   */
+  async cancelImport(importId) {
+    return this.http.post(`/cdn/imports/${importId}/cancel`, {});
+  }
+  /**
+   * Retry failed files in a completed or failed import job
+   *
+   * This resets failed files to pending and re-queues the import for processing.
+   *
+   * @example
+   * ```typescript
+   * const result = await cdn.retryImport('import-id');
+   * console.log(`Retrying ${result.retriedCount} files`);
+   * ```
+   */
+  async retryImport(importId) {
+    return this.http.post(`/cdn/imports/${importId}/retry`, {});
+  }
+  /**
+   * List files in an import job with optional status filter
+   *
+   * @example
+   * ```typescript
+   * // List all files
+   * const { files, total } = await cdn.listImportFiles({
+   *   importId: 'import-id',
+   *   limit: 100,
+   * });
+   *
+   * // List only failed files
+   * const { files: failedFiles } = await cdn.listImportFiles({
+   *   importId: 'import-id',
+   *   status: 'failed',
+   * });
+   *
+   * for (const file of failedFiles) {
+   *   console.log(`${file.sourceKey}: ${file.errorMessage}`);
+   * }
+   * ```
+   */
+  async listImportFiles(request) {
+    const params = new URLSearchParams();
+    if (request.status) params.set("status", request.status);
+    if (request.sortBy) params.set("sortBy", request.sortBy);
+    if (request.sortOrder) params.set("sortOrder", request.sortOrder);
+    if (request.limit) params.set("limit", request.limit.toString());
+    if (request.offset) params.set("offset", request.offset.toString());
+    const query = params.toString();
+    const response = await this.http.get(
+      `/cdn/imports/${request.importId}/files${query ? `?${query}` : ""}`
+    );
+    return {
+      ...response,
+      files: response.files.map((file) => this.convertImportFileDates(file))
+    };
+  }
+  convertCreateImportDates(response) {
+    if (typeof response.createdAt === "string") {
+      response.createdAt = new Date(response.createdAt);
+    }
+    return response;
+  }
+  convertImportJobDates(job) {
+    if (typeof job.createdAt === "string") {
+      job.createdAt = new Date(job.createdAt);
+    }
+    if (job.updatedAt && typeof job.updatedAt === "string") {
+      job.updatedAt = new Date(job.updatedAt);
+    }
+    if (job.startedAt && typeof job.startedAt === "string") {
+      job.startedAt = new Date(job.startedAt);
+    }
+    if (job.completedAt && typeof job.completedAt === "string") {
+      job.completedAt = new Date(job.completedAt);
+    }
+    return job;
+  }
+  convertImportJobSummaryDates(job) {
+    if (typeof job.createdAt === "string") {
+      job.createdAt = new Date(job.createdAt);
+    }
+    if (job.startedAt && typeof job.startedAt === "string") {
+      job.startedAt = new Date(job.startedAt);
+    }
+    if (job.completedAt && typeof job.completedAt === "string") {
+      job.completedAt = new Date(job.completedAt);
+    }
+    return job;
+  }
+  convertImportFileDates(file) {
+    if (typeof file.createdAt === "string") {
+      file.createdAt = new Date(file.createdAt);
+    }
+    if (file.completedAt && typeof file.completedAt === "string") {
+      file.completedAt = new Date(file.completedAt);
+    }
+    if (file.lastAttemptAt && typeof file.lastAttemptAt === "string") {
+      file.lastAttemptAt = new Date(file.lastAttemptAt);
+    }
+    return file;
+  }
 };
 
 // src/screenshots/client.ts
@@ -3511,9 +3804,7 @@ var Productivity = class {
     return this.http.get(`/integrations/productivity/tables/${tableId}/rows?${params}`);
   }
   async getTableRow(connectionId, tableId, rowId) {
-    return this.http.get(
-      `/integrations/productivity/tables/${tableId}/rows/${rowId}?connectionId=${connectionId}`
-    );
+    return this.http.get(`/integrations/productivity/tables/${tableId}/rows/${rowId}?connectionId=${connectionId}`);
   }
   async createTableRow(connectionId, tableId, data) {
     return this.http.post(`/integrations/productivity/tables/${tableId}/rows`, {
@@ -3528,9 +3819,7 @@ var Productivity = class {
     });
   }
   async deleteTableRow(connectionId, tableId, rowId) {
-    return this.http.delete(
-      `/integrations/productivity/tables/${tableId}/rows/${rowId}?connectionId=${connectionId}`
-    );
+    return this.http.delete(`/integrations/productivity/tables/${tableId}/rows/${rowId}?connectionId=${connectionId}`);
   }
 };
 var Integrations = class {
@@ -3657,10 +3946,9 @@ var Integrations = class {
    * ```
    */
   async reconnectConnection(request) {
-    return this.http.post(
-      `/integrations/connections/${request.connectionId}/reconnect`,
-      { redirectUrl: request.redirectUrl }
-    );
+    return this.http.post(`/integrations/connections/${request.connectionId}/reconnect`, {
+      redirectUrl: request.redirectUrl
+    });
   }
   /**
    * Get integration statistics
@@ -3704,9 +3992,7 @@ var Integrations = class {
     if (request?.limit) params.set("limit", request.limit.toString());
     if (request?.cursor) params.set("cursor", request.cursor);
     const queryString = params.toString();
-    const response = await this.http.get(
-      `/integrations/logs${queryString ? `?${queryString}` : ""}`
-    );
+    const response = await this.http.get(`/integrations/logs${queryString ? `?${queryString}` : ""}`);
     return {
       ...response,
       logs: response.logs.map((log) => this.convertLogDates(log))
@@ -4550,6 +4836,535 @@ var Marketing = class {
   }
 };
 
+// src/workflows/client.ts
+var Workflows = class {
+  http;
+  constructor(config) {
+    this.http = new HttpClient(config);
+  }
+  // ==========================================================================
+  // WORKFLOW CRUD
+  // ==========================================================================
+  /**
+   * Create a new workflow
+   *
+   * @example
+   * ```typescript
+   * const workflow = await workflows.create({
+   *   slug: 'content-pipeline',
+   *   name: 'Content Generation Pipeline',
+   *   steps: [
+   *     {
+   *       id: 'generate',
+   *       name: 'Generate Content',
+   *       type: 'llm',
+   *       provider: 'anthropic',
+   *       model: 'claude-sonnet-4-20250514',
+   *       config: {
+   *         prompt: 'Write a blog post about {{topic}}',
+   *         maxTokens: 2000,
+   *       },
+   *     },
+   *   ],
+   *   variables: [
+   *     { name: 'topic', type: 'string', required: true },
+   *   ],
+   * });
+   * ```
+   */
+  async create(request) {
+    return this.http.post("/workflows/workflows", request);
+  }
+  /**
+   * Get a workflow by ID or slug
+   *
+   * @example
+   * ```typescript
+   * const workflow = await workflows.get({ slug: 'content-pipeline' });
+   * console.log(workflow.steps);
+   * ```
+   */
+  async get(request) {
+    const params = new URLSearchParams();
+    if (request.slug) params.set("slug", request.slug);
+    if (request.environment) params.set("environment", request.environment);
+    if (request.projectSlug) params.set("projectSlug", request.projectSlug);
+    const path = request.id ? `/workflows/workflows/${request.id}` : `/workflows/workflows?${params.toString()}`;
+    const response = await this.http.get(path);
+    return this.convertDates(response);
+  }
+  /**
+   * List workflows with pagination
+   *
+   * @example
+   * ```typescript
+   * const { items, nextCursor } = await workflows.list({
+   *   environment: 'production',
+   *   isActive: true,
+   *   limit: 20,
+   * });
+   * ```
+   */
+  async list(request = {}) {
+    const params = new URLSearchParams();
+    if (request.projectSlug) params.set("projectSlug", request.projectSlug);
+    if (request.environment) params.set("environment", request.environment);
+    if (request.isActive !== void 0) params.set("isActive", request.isActive.toString());
+    if (request.limit) params.set("limit", request.limit.toString());
+    if (request.cursor) params.set("cursor", request.cursor);
+    const query = params.toString();
+    const response = await this.http.get(
+      `/workflows/workflows${query ? `?${query}` : ""}`
+    );
+    return {
+      ...response,
+      items: response.items.map((item) => this.convertDates(item))
+    };
+  }
+  /**
+   * Update a workflow
+   *
+   * @example
+   * ```typescript
+   * await workflows.update({
+   *   id: 'workflow-id',
+   *   name: 'Updated Pipeline',
+   *   isActive: false,
+   * });
+   * ```
+   */
+  async update(request) {
+    const { id, ...data } = request;
+    return this.http.post(
+      `/workflows/workflows/${id}`,
+      data
+    );
+  }
+  /**
+   * Delete a workflow
+   *
+   * @example
+   * ```typescript
+   * await workflows.delete({ id: 'workflow-id' });
+   * ```
+   */
+  async delete(request) {
+    return this.http.deleteWithBody(
+      `/workflows/workflows/${request.id}`,
+      request
+    );
+  }
+  // ==========================================================================
+  // WORKFLOW EXECUTION
+  // ==========================================================================
+  /**
+   * Run a workflow
+   *
+   * @example
+   * ```typescript
+   * const run = await workflows.run({
+   *   workflowSlug: 'content-pipeline',
+   *   variables: {
+   *     topic: 'artificial intelligence',
+   *   },
+   *   webhook: {
+   *     url: 'https://example.com/webhook',
+   *     secret: 'webhook-secret',
+   *   },
+   * });
+   * console.log(run.id, run.status);
+   * ```
+   */
+  async run(request) {
+    return this.http.post("/workflows/workflows/run", request);
+  }
+  /**
+   * Get a workflow run by ID
+   *
+   * @example
+   * ```typescript
+   * const run = await workflows.getRun({ id: 'run-id' });
+   * if (run.status === 'completed') {
+   *   console.log(run.output);
+   * }
+   * ```
+   */
+  async getRun(request) {
+    const params = new URLSearchParams();
+    if (request.environment) params.set("environment", request.environment);
+    if (request.projectSlug) params.set("projectSlug", request.projectSlug);
+    const query = params.toString();
+    const response = await this.http.get(
+      `/workflows/workflows/runs/${request.id}${query ? `?${query}` : ""}`
+    );
+    return this.convertRunDates(response);
+  }
+  /**
+   * List workflow runs with pagination
+   *
+   * @example
+   * ```typescript
+   * const { items } = await workflows.listRuns({
+   *   workflowId: 'workflow-id',
+   *   status: 'completed',
+   * });
+   * ```
+   */
+  async listRuns(request = {}) {
+    const params = new URLSearchParams();
+    if (request.workflowId) params.set("workflowId", request.workflowId);
+    if (request.workflowSlug) params.set("workflowSlug", request.workflowSlug);
+    if (request.projectSlug) params.set("projectSlug", request.projectSlug);
+    if (request.environment) params.set("environment", request.environment);
+    if (request.status) params.set("status", request.status);
+    if (request.limit) params.set("limit", request.limit.toString());
+    if (request.cursor) params.set("cursor", request.cursor);
+    const query = params.toString();
+    const response = await this.http.get(
+      `/workflows/workflows/runs${query ? `?${query}` : ""}`
+    );
+    return {
+      ...response,
+      items: response.items.map((item) => this.convertRunDates(item))
+    };
+  }
+  /**
+   * Cancel a running workflow
+   *
+   * @example
+   * ```typescript
+   * await workflows.cancelRun({ id: 'run-id' });
+   * ```
+   */
+  async cancelRun(request) {
+    return this.http.post(
+      `/workflows/workflows/runs/${request.id}/cancel`,
+      {}
+    );
+  }
+  /**
+   * Run a workflow and wait for completion
+   *
+   * @example
+   * ```typescript
+   * const run = await workflows.runAndWait({
+   *   workflowSlug: 'content-pipeline',
+   *   variables: { topic: 'AI' },
+   * });
+   * console.log(run.output);
+   * ```
+   */
+  async runAndWait(request, options = {}) {
+    const { pollInterval = 2e3, timeout = 6e5 } = options;
+    const startTime = Date.now();
+    const { id } = await this.run(request);
+    while (Date.now() - startTime < timeout) {
+      const run = await this.getRun({
+        id,
+        environment: request.environment,
+        projectSlug: request.projectSlug
+      });
+      if (run.status === "completed" || run.status === "failed" || run.status === "cancelled") {
+        if (run.status === "failed") {
+          throw new Error(run.error || "Workflow execution failed");
+        }
+        return run;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error("Workflow execution timed out");
+  }
+  // ==========================================================================
+  // HELPERS
+  // ==========================================================================
+  convertDates(workflow) {
+    if (typeof workflow.createdAt === "string") {
+      workflow.createdAt = new Date(workflow.createdAt);
+    }
+    if (typeof workflow.updatedAt === "string") {
+      workflow.updatedAt = new Date(workflow.updatedAt);
+    }
+    return workflow;
+  }
+  convertRunDates(run) {
+    if (typeof run.createdAt === "string") {
+      run.createdAt = new Date(run.createdAt);
+    }
+    if (run.startedAt && typeof run.startedAt === "string") {
+      run.startedAt = new Date(run.startedAt);
+    }
+    if (run.completedAt && typeof run.completedAt === "string") {
+      run.completedAt = new Date(run.completedAt);
+    }
+    return run;
+  }
+};
+
+// src/memory/agents.ts
+var MemoryAgents = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new memory agent
+   */
+  async create(request) {
+    return this.http.post("/memory/agents", request);
+  }
+  /**
+   * List all memory agents
+   */
+  async list(params = {}) {
+    const qs = new URLSearchParams();
+    if (params.environment) qs.set("environment", params.environment);
+    const q = qs.toString();
+    return this.http.get(`/memory/agents${q ? `?${q}` : ""}`);
+  }
+  /**
+   * Get a memory agent by ID
+   */
+  async get(agentId) {
+    return this.http.get(`/memory/agents/${agentId}`);
+  }
+  /**
+   * Update a memory agent
+   */
+  async update(agentId, request) {
+    return this.http.patch(`/memory/agents/${agentId}`, request);
+  }
+  /**
+   * Delete a memory agent
+   */
+  async delete(agentId) {
+    return this.http.delete(`/memory/agents/${agentId}`);
+  }
+};
+
+// src/memory/collections.ts
+var MemoryCollections = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new collection for an agent
+   */
+  async create(request) {
+    return this.http.post(`/memory/agents/${request.agentId}/collections`, {
+      name: request.name,
+      slug: request.slug,
+      description: request.description,
+      compaction: request.compaction,
+      retention: request.retention
+    });
+  }
+  /**
+   * List all collections for an agent
+   */
+  async list(agentId) {
+    return this.http.get(`/memory/agents/${agentId}/collections`);
+  }
+  /**
+   * Get a collection by slug
+   */
+  async get(agentId, collectionSlug) {
+    return this.http.get(`/memory/agents/${agentId}/collections/${collectionSlug}`);
+  }
+  /**
+   * Update a collection
+   */
+  async update(agentId, collectionSlug, request) {
+    return this.http.patch(
+      `/memory/agents/${agentId}/collections/${collectionSlug}`,
+      request
+    );
+  }
+  /**
+   * Delete a collection
+   */
+  async delete(agentId, collectionSlug) {
+    return this.http.delete(`/memory/agents/${agentId}/collections/${collectionSlug}`);
+  }
+  /**
+   * Get collection statistics
+   */
+  async stats(agentId, collectionSlug) {
+    return this.http.get(
+      `/memory/agents/${agentId}/collections/${collectionSlug}/stats`
+    );
+  }
+  /**
+   * Trigger compaction for a collection
+   */
+  async compact(agentId, collectionSlug, request = {}) {
+    return this.http.post(
+      `/memory/agents/${agentId}/collections/${collectionSlug}/compact`,
+      request
+    );
+  }
+  /**
+   * Get a compaction job by ID
+   */
+  async getCompactionJob(agentId, collectionSlug, jobId) {
+    return this.http.get(
+      `/memory/agents/${agentId}/collections/${collectionSlug}/compact/${jobId}`
+    );
+  }
+};
+
+// src/memory/entities.ts
+var MemoryEntities = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list(params) {
+    const qs = new URLSearchParams();
+    qs.set("agentId", params.agentId);
+    if (params.type) qs.set("type", params.type);
+    if (params.limit) qs.set("limit", params.limit.toString());
+    if (params.offset) qs.set("offset", params.offset.toString());
+    const q = qs.toString();
+    return this.http.get(`/memory/entities${q ? `?${q}` : ""}`);
+  }
+  async get(entityId) {
+    return this.http.get(`/memory/entities/${entityId}`);
+  }
+  async getRelations(entityId) {
+    return this.http.get(`/memory/entities/${entityId}/relations`);
+  }
+};
+
+// src/memory/client.ts
+var Memory = class {
+  http;
+  /** Manage memory agents */
+  agents;
+  /** Manage memory collections */
+  collections;
+  /** Manage extracted entities */
+  entities;
+  constructor(config) {
+    this.http = new HttpClient(config);
+    this.agents = new MemoryAgents(this.http);
+    this.collections = new MemoryCollections(this.http);
+    this.entities = new MemoryEntities(this.http);
+  }
+  // ============================================================================
+  // MEMORY OPERATIONS
+  // ============================================================================
+  /**
+   * Store a memory
+   *
+   * @example
+   * ```typescript
+   * const memory = await stack0.memory.store({
+   *   agentId: 'agent_123',
+   *   content: 'User prefers dark mode',
+   *   type: 'preference',
+   *   tags: ['ui', 'settings'],
+   * });
+   * ```
+   */
+  async store(request) {
+    return this.http.post("/memory/memories", request);
+  }
+  /**
+   * Store multiple memories in a batch
+   *
+   * @example
+   * ```typescript
+   * const results = await stack0.memory.storeBatch({
+   *   agentId: 'agent_123',
+   *   memories: [
+   *     { content: 'User prefers dark mode', type: 'preference' },
+   *     { content: 'User is based in NYC', type: 'fact' },
+   *   ],
+   * });
+   * ```
+   */
+  async storeBatch(request) {
+    return this.http.post("/memory/memories/batch", request);
+  }
+  /**
+   * Recall memories using semantic search (vector similarity)
+   *
+   * @example
+   * ```typescript
+   * const results = await stack0.memory.recall({
+   *   agentId: 'agent_123',
+   *   query: 'What are the user preferences?',
+   *   limit: 10,
+   * });
+   * ```
+   */
+  async recall(request) {
+    return this.http.post("/memory/memories/recall", request);
+  }
+  /**
+   * Search memories using full-text search
+   *
+   * @example
+   * ```typescript
+   * const results = await stack0.memory.search({
+   *   agentId: 'agent_123',
+   *   query: 'dark mode',
+   *   limit: 20,
+   * });
+   * ```
+   */
+  async search(request) {
+    return this.http.post("/memory/memories/search", request);
+  }
+  /**
+   * Get a memory by ID
+   */
+  async get(memoryId) {
+    return this.http.get(`/memory/memories/${memoryId}`);
+  }
+  /**
+   * List memories with optional filters
+   *
+   * @example
+   * ```typescript
+   * const memories = await stack0.memory.list({
+   *   agentId: 'agent_123',
+   *   type: 'preference',
+   *   limit: 50,
+   * });
+   * ```
+   */
+  async list(params) {
+    const qs = new URLSearchParams();
+    qs.set("agentId", params.agentId);
+    if (params.collectionSlug) qs.set("collectionSlug", params.collectionSlug);
+    if (params.type) qs.set("type", params.type);
+    if (params.tier) qs.set("tier", params.tier);
+    if (params.limit) qs.set("limit", params.limit.toString());
+    if (params.offset) qs.set("offset", params.offset.toString());
+    if (params.sortBy) qs.set("sortBy", params.sortBy);
+    if (params.sortOrder) qs.set("sortOrder", params.sortOrder);
+    const q = qs.toString();
+    return this.http.get(`/memory/memories${q ? `?${q}` : ""}`);
+  }
+  /**
+   * Update a memory
+   */
+  async update(memoryId, request) {
+    return this.http.patch(`/memory/memories/${memoryId}`, request);
+  }
+  /**
+   * Delete a memory by ID
+   */
+  async delete(memoryId) {
+    return this.http.delete(`/memory/memories/${memoryId}`);
+  }
+  /**
+   * Delete multiple memories
+   */
+  async deleteMany(request) {
+    return this.http.deleteWithBody("/memory/memories", request);
+  }
+};
+
 // src/index.ts
 var Stack0 = class {
   mail;
@@ -4558,6 +5373,8 @@ var Stack0 = class {
   extraction;
   integrations;
   marketing;
+  workflows;
+  memory;
   /**
    * @deprecated Use `screenshots` and `extraction` instead. Will be removed in a future version.
    */
@@ -4573,11 +5390,13 @@ var Stack0 = class {
     this.extraction = new Extraction(clientConfig);
     this.integrations = new Integrations(clientConfig);
     this.marketing = new Marketing(clientConfig);
+    this.workflows = new Workflows(clientConfig);
+    this.memory = new Memory(clientConfig);
     this.webdata = new Webdata(clientConfig);
   }
 };
 var src_default = Stack0;
 
-export { Audiences, CDN, Campaigns, Contacts, Domains, Events, Extraction, Integrations, Mail, Marketing, Screenshots, Sequences, Stack0, Templates, Webdata, src_default as default };
+export { Audiences, CDN, Campaigns, Contacts, Domains, Events, Extraction, Integrations, Mail, Marketing, Memory, MemoryAgents, MemoryCollections, MemoryEntities, Screenshots, Sequences, Stack0, Templates, Webdata, Workflows, src_default as default };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map