@stack0/sdk 0.5.8 → 0.5.9

package/dist/index.js

@@ -963,6 +963,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
    *
@@ -2015,6 +2036,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
@@ -4621,6 +4840,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;
@@ -4629,6 +5377,8 @@ var Stack0 = class {
   extraction;
   integrations;
   marketing;
+  workflows;
+  memory;
   /**
    * @deprecated Use `screenshots` and `extraction` instead. Will be removed in a future version.
    */
@@ -4644,6 +5394,8 @@ 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);
   }
 };
@@ -4659,11 +5411,16 @@ exports.Extraction = Extraction;
 exports.Integrations = Integrations;
 exports.Mail = Mail;
 exports.Marketing = Marketing;
+exports.Memory = Memory;
+exports.MemoryAgents = MemoryAgents;
+exports.MemoryCollections = MemoryCollections;
+exports.MemoryEntities = MemoryEntities;
 exports.Screenshots = Screenshots;
 exports.Sequences = Sequences;
 exports.Stack0 = Stack0;
 exports.Templates = Templates;
 exports.Webdata = Webdata;
+exports.Workflows = Workflows;
 exports.default = src_default;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map