@swarm-agent/sdk 0.1.47

package/dist/deploy/manifest.js

@@ -0,0 +1,220 @@
+/**
+ * Manifest parsing, creation, and resolution for Swarm deployments.
+ */
+import { SwarmValidationError } from '../errors.js';
+const CANONICAL_REPO = 'https://github.com/swarm-agent/swarm';
+/**
+ * Creates a well-formed SwarmDeployManifest using proven best-practice presets.
+ */
+export function createDeployManifest(options = {}) {
+    const preset = options.preset || 'latency-optimized';
+    const name = options.name || 'swarm-agent-service';
+    // Base source defaults to canonical GitHub repo
+    const source = {
+        type: 'github',
+        repository: CANONICAL_REPO,
+        branch: 'main',
+        buildStrategy: 'distroless',
+        ...options.source,
+    };
+    let target = options.target;
+    let gcpCloudRun;
+    let gcpCompute;
+    switch (preset) {
+        case 'latency-optimized':
+            target = target || 'gcp-cloud-run';
+            gcpCloudRun = {
+                projectId: '${PROJECT_ID}',
+                region: 'us-central1',
+                serviceName: 'swarmd',
+                cpu: '1',
+                memory: '512Mi',
+                minInstances: 0,
+                maxInstances: 10,
+                concurrency: 80,
+                port: 18080,
+                cpuBoost: true,
+                executionEnvironment: 'gen2',
+                allowUnauthenticated: false,
+                timeoutSeconds: 300,
+                ingress: 'all',
+                ...options.gcpCloudRun,
+            };
+            break;
+        case 'zero-idle-cost':
+            target = target || 'gcp-cloud-run';
+            gcpCloudRun = {
+                projectId: '${PROJECT_ID}',
+                region: 'us-central1',
+                serviceName: 'swarmd-serverless',
+                cpu: '1',
+                memory: '512Mi',
+                minInstances: 0,
+                maxInstances: 5,
+                concurrency: 80,
+                port: 18080,
+                cpuBoost: true,
+                executionEnvironment: 'gen2',
+                allowUnauthenticated: false,
+                timeoutSeconds: 300,
+                ingress: 'all',
+                ...options.gcpCloudRun,
+            };
+            break;
+        case 'always-on':
+            target = target || 'gcp-cloud-run';
+            gcpCloudRun = {
+                projectId: '${PROJECT_ID}',
+                region: 'us-central1',
+                serviceName: 'swarmd-always-on',
+                cpu: '1',
+                memory: '512Mi',
+                minInstances: 1,
+                maxInstances: 20,
+                concurrency: 80,
+                port: 18080,
+                cpuBoost: true,
+                executionEnvironment: 'gen2',
+                allowUnauthenticated: false,
+                timeoutSeconds: 300,
+                ingress: 'all',
+                ...options.gcpCloudRun,
+            };
+            break;
+        case 'free-tier-vm':
+            target = target || 'gcp-compute-engine';
+            gcpCompute = {
+                projectId: '${PROJECT_ID}',
+                zone: 'us-central1-a',
+                instanceName: 'swarm-free-vm',
+                machineType: 'e2-micro',
+                diskSizeGb: 30,
+                diskType: 'pd-standard',
+                preemptible: false,
+                port: 18080,
+                tags: ['swarm-agent', 'http-server'],
+                ...options.gcpCompute,
+            };
+            break;
+        case 'high-concurrency-vm':
+            target = target || 'gcp-compute-engine';
+            gcpCompute = {
+                projectId: '${PROJECT_ID}',
+                zone: 'us-central1-a',
+                instanceName: 'swarm-cluster-node',
+                machineType: 'e2-small',
+                diskSizeGb: 50,
+                diskType: 'pd-balanced',
+                preemptible: false,
+                port: 18080,
+                tags: ['swarm-agent', 'http-server'],
+                ...options.gcpCompute,
+            };
+            break;
+        default:
+            target = target || 'gcp-cloud-run';
+            gcpCloudRun = {
+                projectId: '${PROJECT_ID}',
+                region: 'us-central1',
+                serviceName: 'swarmd',
+                cpu: '1',
+                memory: '512Mi',
+                minInstances: 0,
+                maxInstances: 10,
+                concurrency: 80,
+                port: 18080,
+                cpuBoost: true,
+                executionEnvironment: 'gen2',
+                allowUnauthenticated: false,
+                ...options.gcpCloudRun,
+            };
+    }
+    // Ensure default target if not set
+    if (!target) {
+        target = 'gcp-cloud-run';
+    }
+    return {
+        version: '1.0',
+        name,
+        target,
+        source,
+        ...(options.context ? { context: options.context } : {}),
+        ...(gcpCloudRun ? { gcpCloudRun } : {}),
+        ...(gcpCompute ? { gcpCompute } : {}),
+        env: options.env || { SWARM_ENV: 'production' },
+        secrets: options.secrets || {},
+        labels: options.labels || { managed_by: 'swarm_sdk' },
+    };
+}
+/**
+ * Loads, validates, and resolves a SwarmDeployManifest from a JSON string or raw object.
+ * Automatically expands ${VAR_NAME} placeholders using environment variables or optional dictionary.
+ */
+export function loadDeployManifest(input, envLookup) {
+    let raw;
+    if (typeof input === 'string') {
+        try {
+            raw = JSON.parse(input);
+        }
+        catch (err) {
+            throw new SwarmValidationError(`Failed to parse Swarm deployment manifest JSON: ${err.message}`);
+        }
+    }
+    else if (typeof input === 'object' && input !== null) {
+        raw = { ...input };
+    }
+    else {
+        throw new SwarmValidationError('Deployment manifest must be a JSON string or an object');
+    }
+    // Interpolate ${VAR} placeholders
+    const resolved = interpolateEnvVars(raw, envLookup);
+    // Validate core schema
+    if (resolved.version !== '1.0') {
+        throw new SwarmValidationError(`Invalid manifest version: expected '1.0', got '${String(resolved.version)}'`);
+    }
+    if (!resolved.name || typeof resolved.name !== 'string') {
+        throw new SwarmValidationError("Deployment manifest requires a non-empty string 'name'");
+    }
+    if (!resolved.target || typeof resolved.target !== 'string') {
+        throw new SwarmValidationError("Deployment manifest requires a non-empty string 'target'");
+    }
+    if (!resolved.source || typeof resolved.source !== 'object') {
+        throw new SwarmValidationError("Deployment manifest requires a 'source' object");
+    }
+    const source = resolved.source;
+    if (!source.type || !['github', 'local', 'binary'].includes(String(source.type))) {
+        throw new SwarmValidationError("Manifest source.type must be one of: 'github', 'local', 'binary'");
+    }
+    return resolved;
+}
+/**
+ * Serializes a deployment manifest to formatted JSON.
+ */
+export function serializeDeployManifest(manifest, indent = 2) {
+    return JSON.stringify(manifest, null, indent);
+}
+function interpolateEnvVars(val, envLookup) {
+    if (typeof val === 'string') {
+        return val.replace(/\$\{([a-zA-Z0-9_]+)\}/g, (_, varName) => {
+            if (envLookup && varName in envLookup) {
+                return envLookup[varName];
+            }
+            if (typeof process !== 'undefined' && process?.env && varName in process.env) {
+                return process.env[varName] || '';
+            }
+            // Retain placeholder if unresolved so command generators can use shell variables
+            return `\${${varName}}`;
+        });
+    }
+    if (Array.isArray(val)) {
+        return val.map((item) => interpolateEnvVars(item, envLookup));
+    }
+    if (typeof val === 'object' && val !== null) {
+        const res = {};
+        for (const [k, v] of Object.entries(val)) {
+            res[k] = interpolateEnvVars(v, envLookup);
+        }
+        return res;
+    }
+    return val;
+}

package/dist/deploy/providers/gcp-cloud-run.d.ts

@@ -0,0 +1,9 @@
+import type { CloudDeployProvider, DeployCommand, DeployPlan, SwarmDeployManifest, ValidationResult } from '../types.js';
+/** Retained only to give existing callers an explicit migration error. */
+export declare class GcpCloudRunProvider implements CloudDeployProvider {
+    readonly target = "gcp-cloud-run";
+    validate(_manifest: SwarmDeployManifest): ValidationResult;
+    generateArtifacts(_manifest: SwarmDeployManifest): Record<string, string>;
+    generateCommands(_manifest: SwarmDeployManifest): DeployCommand[];
+    plan(_manifest: SwarmDeployManifest): DeployPlan;
+}

package/dist/deploy/providers/gcp-cloud-run.js

@@ -0,0 +1,12 @@
+import { SwarmValidationError } from '../../errors.js';
+const reason = 'Cloud Run deployment is unsupported: ephemeral/scaled instances cannot own the single-writer durable Swarm store. Use a qualified immutable headless image with persistent volumes and a private same-container BFF. Worker deployment requires Swarm Orchestrator approval.';
+/** Retained only to give existing callers an explicit migration error. */
+export class GcpCloudRunProvider {
+    target = 'gcp-cloud-run';
+    validate(_manifest) {
+        return { valid: false, errors: [reason], warnings: [] };
+    }
+    generateArtifacts(_manifest) { throw new SwarmValidationError(reason); }
+    generateCommands(_manifest) { throw new SwarmValidationError(reason); }
+    plan(_manifest) { throw new SwarmValidationError(reason); }
+}

package/dist/deploy/providers/gcp-compute.d.ts

@@ -0,0 +1,9 @@
+import type { CloudDeployProvider, DeployCommand, DeployPlan, SwarmDeployManifest, ValidationResult } from '../types.js';
+/** No second daemon installer or implicit cloud provisioning authority. */
+export declare class GcpComputeEngineProvider implements CloudDeployProvider {
+    readonly target = "gcp-compute-engine";
+    validate(_manifest: SwarmDeployManifest): ValidationResult;
+    generateArtifacts(_manifest: SwarmDeployManifest): Record<string, string>;
+    generateCommands(_manifest: SwarmDeployManifest): DeployCommand[];
+    plan(_manifest: SwarmDeployManifest): DeployPlan;
+}

package/dist/deploy/providers/gcp-compute.js

@@ -0,0 +1,12 @@
+import { SwarmValidationError } from '../../errors.js';
+const reason = 'Legacy Compute Engine provisioning is unsupported: its source build, public daemon and storage paths do not match the canonical runtime. Provision an approved single-writer host separately and use the qualified immutable headless image with persistent volumes and a private same-container BFF.';
+/** No second daemon installer or implicit cloud provisioning authority. */
+export class GcpComputeEngineProvider {
+    target = 'gcp-compute-engine';
+    validate(_manifest) {
+        return { valid: false, errors: [reason], warnings: [] };
+    }
+    generateArtifacts(_manifest) { throw new SwarmValidationError(reason); }
+    generateCommands(_manifest) { throw new SwarmValidationError(reason); }
+    plan(_manifest) { throw new SwarmValidationError(reason); }
+}

package/dist/deploy/types.d.ts

@@ -0,0 +1,211 @@
+/**
+ * Types and interfaces for Swarm multi-cloud deployment automation.
+ */
+export type CloudTarget = 'gcp-cloud-run' | 'gcp-compute-engine' | 'docker' | string;
+export type BuildStrategy = 'distroless' | 'scratch' | 'alpine' | 'prebuilt-binary';
+export interface SourceConfig {
+    /** Source location type: 'github' clone, 'local' directory, or 'binary' download */
+    type: 'github' | 'local' | 'binary';
+    /** Canonical Git repository URL (defaults to https://github.com/swarm-agent/swarm) */
+    repository?: string;
+    /** Git branch, tag, or ref to build (defaults to 'main') */
+    branch?: string;
+    /** Specific Git commit SHA to checkout */
+    commit?: string;
+    /** Direct URL to precompiled swarmd binary if type is 'binary' */
+    binaryUrl?: string;
+    /** Workspace-relative or absolute path if type is 'local' */
+    localPath?: string;
+    /** Container build strategy (defaults to 'distroless' for optimal cold start) */
+    buildStrategy?: BuildStrategy;
+}
+export interface AgentContextConfig {
+    /** System instructions or AGENTS.md content to guide the headless agent */
+    instructions?: string;
+    /** Initial task, mission, or prompt to execute on startup */
+    prompt?: string;
+    /** Target AI model identifier (e.g. 'gemini-3.8-flash') */
+    model?: string;
+    /** Thinking level ('low' | 'medium' | 'high') */
+    thinking?: 'low' | 'medium' | 'high';
+    /** Target workspace Git repository URL or path */
+    workspaceUrl?: string;
+    /** Workspace Git branch (defaults to 'main') */
+    workspaceBranch?: string;
+    /** Optional custom shell hook script to run during boot/context reload */
+    bootHook?: string;
+}
+export interface GcpCloudRunConfig {
+    /** Target GCP project ID (defaults to ${PROJECT_ID} placeholder or GCP_PROJECT env) */
+    projectId?: string;
+    /** GCP region (defaults to 'us-central1') */
+    region?: string;
+    /** Cloud Run service name (defaults to 'swarm-daemon') */
+    serviceName?: string;
+    /** Container CPU allocation (e.g. '1', '2') */
+    cpu?: string;
+    /** Container memory limit (e.g. '512Mi', '1Gi', '2Gi') - 512Mi is optimal for low cold start */
+    memory?: string;
+    /** Minimum instances (0 for pure scale-to-zero, $0 idle cost; 1 for zero cold-start warm pool) */
+    minInstances?: number;
+    /** Maximum instances (e.g. 10, 50, 100) */
+    maxInstances?: number;
+    /** Maximum concurrent requests per instance (default: 80) */
+    concurrency?: number;
+    /** Container listen port (default: 18080 or Cloud Run $PORT) */
+    port?: number;
+    /** Enable Startup CPU Boost for <1.5s cold-start latency (default: true) */
+    cpuBoost?: boolean;
+    /** Cloud Run execution environment: 'gen2' (recommended) or 'gen1' */
+    executionEnvironment?: 'gen1' | 'gen2';
+    /** Allow unauthenticated public invocations (default: false) */
+    allowUnauthenticated?: boolean;
+    /** Attached service account email */
+    serviceAccount?: string;
+    /** Network ingress traffic filter: 'all' | 'internal' | 'internal-and-cloud-load-balancing' */
+    ingress?: 'all' | 'internal' | 'internal-and-cloud-load-balancing';
+    /** Request timeout in seconds (default: 300) */
+    timeoutSeconds?: number;
+    /** Additional container image tag or Artifact Registry URL */
+    imageUri?: string;
+}
+export interface GcpComputeEngineConfig {
+    /** Target GCP project ID */
+    projectId?: string;
+    /** GCP compute zone (defaults to 'us-central1-a') */
+    zone?: string;
+    /** Compute instance name (defaults to 'swarm-vm') */
+    instanceName?: string;
+    /** GCE machine type (e.g. 'e2-micro' for free tier, 'e2-small' for 100 agents, 'e2-standard-4') */
+    machineType?: string;
+    /** Boot disk size in GB (default: 30 for GCP Free Tier) */
+    diskSizeGb?: number;
+    /** Boot disk type: 'pd-standard' | 'pd-ssd' | 'pd-balanced' */
+    diskType?: 'pd-standard' | 'pd-ssd' | 'pd-balanced';
+    /** Use preemptible/spot instance for lowest cost */
+    preemptible?: boolean;
+    /** Attached service account email */
+    serviceAccount?: string;
+    /** Network tags */
+    tags?: string[];
+    /** Listen port (default: 18080) */
+    port?: number;
+    /** Enable dynamic GCP metadata context syncing (/usr/local/bin/swarm-sync-context) */
+    enableMetadataSync?: boolean;
+}
+export interface SwarmDeployManifest {
+    /** Schema specification version (e.g. '1.0') */
+    version: '1.0';
+    /** Human-readable deployment name or service title */
+    name: string;
+    /** Target deployment platform */
+    target: CloudTarget;
+    /** Source code and binary build configuration */
+    source: SourceConfig;
+    /** Agent role, instructions, prompt, and workspace context */
+    context?: AgentContextConfig;
+    /** GCP Cloud Run specific configuration (when target is 'gcp-cloud-run') */
+    gcpCloudRun?: GcpCloudRunConfig;
+    /** GCP Compute Engine specific configuration (when target is 'gcp-compute-engine') */
+    gcpCompute?: GcpComputeEngineConfig;
+    /** Environment variables to inject into the deployment */
+    env?: Record<string, string>;
+    /** Secret Manager secret references (env var -> secret resource name) */
+    secrets?: Record<string, string>;
+    /** Resource metadata labels */
+    labels?: Record<string, string>;
+}
+export type DeploymentPreset = 'latency-optimized' | 'zero-idle-cost' | 'always-on' | 'free-tier-vm' | 'high-concurrency-vm';
+export interface CreateManifestOptions {
+    /** Deployment preset providing pre-tuned performance and cost defaults */
+    preset?: DeploymentPreset;
+    /** Deployment name */
+    name?: string;
+    /** Target platform override */
+    target?: CloudTarget;
+    /** Source configuration overrides */
+    source?: Partial<SourceConfig>;
+    /** Agent role, instructions, prompt, and workspace context */
+    context?: Partial<AgentContextConfig>;
+    /** GCP Cloud Run configuration overrides */
+    gcpCloudRun?: Partial<GcpCloudRunConfig>;
+    /** GCP Compute Engine configuration overrides */
+    gcpCompute?: Partial<GcpComputeEngineConfig>;
+    /** Environment variables */
+    env?: Record<string, string>;
+    /** Secrets */
+    secrets?: Record<string, string>;
+    /** Labels */
+    labels?: Record<string, string>;
+}
+export interface DeployCommand {
+    /** Cosmetic step title */
+    title: string;
+    /** Shell command to execute */
+    command: string;
+    /** Plain-English explanation of the command's effect */
+    explanation: string;
+    /** Pipeline phase */
+    phase: 'build' | 'deploy' | 'verify' | 'cleanup';
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+export interface DeployPlan {
+    /** Canonical resolved deployment manifest */
+    manifest: SwarmDeployManifest;
+    /** Target platform */
+    target: CloudTarget;
+    /** High-level summary of the deployment architecture and cost profile */
+    summary: string;
+    /** Generated deployment artifacts (filename -> content) such as Dockerfile, scripts */
+    artifacts: Record<string, string>;
+    /** Sequential commands to build, deploy, and verify */
+    commands: DeployCommand[];
+    /** Recommended settings applied */
+    recommendations: string[];
+    /** Actionable warnings or prerequisites */
+    warnings: string[];
+}
+export interface CloudDeployProvider {
+    /** Supported cloud target identifier */
+    readonly target: CloudTarget;
+    /** Validates manifest configuration against provider requirements */
+    validate(manifest: SwarmDeployManifest): ValidationResult;
+    /** Generates a complete structured deployment plan */
+    plan(manifest: SwarmDeployManifest): DeployPlan;
+    /** Generates standalone file artifacts (Dockerfile, scripts, config) */
+    generateArtifacts(manifest: SwarmDeployManifest): Record<string, string>;
+    /** Generates shell commands required to execute the deployment */
+    generateCommands(manifest: SwarmDeployManifest): DeployCommand[];
+}
+export interface ExecuteDeployOptions {
+    /** Target directory to write artifacts before execution (defaults to temporary directory) */
+    outputDir?: string;
+    /** Dry-run mode: generates artifacts and validates commands without executing shell operations */
+    dryRun?: boolean;
+    /** Custom logger function for streaming command execution stdout/stderr */
+    onLog?: (line: string, phase: string) => void;
+    /** Additional environment variable overrides for execution processes */
+    env?: Record<string, string>;
+}
+export interface DeployExecutionResult {
+    /** Whether the deployment completed successfully */
+    success: boolean;
+    /** Target deployment platform */
+    target: CloudTarget;
+    /** Total elapsed time in milliseconds */
+    durationMs: number;
+    /** Captured outputs by step title */
+    stepOutputs: Record<string, string>;
+    /** Deployed service URL (if Cloud Run) */
+    serviceUrl?: string;
+    /** External/NAT IP address (if Compute Engine) */
+    externalIp?: string;
+    /** Path to output directory containing written artifacts */
+    outputDir: string;
+    /** Error message if deployment failed */
+    error?: string;
+}

package/dist/deploy/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types and interfaces for Swarm multi-cloud deployment automation.
+ */
+export {};

package/dist/deploy/worker-cloud-deployer.d.ts

@@ -0,0 +1,33 @@
+import type { WorkerStorageHub } from '../storage/hub.js';
+import type { WorkerActorSpec } from '../storage/types.js';
+export interface WorkerDeployValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+export interface CloudRunJobDeployCommands {
+    jobDeployCommand: string;
+    jobDeployArgs: string[];
+    schedulerCommand?: string;
+    schedulerArgs?: string[];
+}
+export interface TaskExecuteCommand {
+    executeCommand: string;
+    executeArgs: string[];
+}
+/** Compatibility tombstone: never provision a parallel worker runtime. */
+export declare class WorkerCloudDeployer {
+    static validate(_spec: WorkerActorSpec): WorkerDeployValidationResult;
+    static createDefaultSpec(_params: {
+        id: string;
+        name: string;
+        description?: string;
+        instructions: string;
+        model?: string;
+        gcpProject?: string;
+        cronSchedule?: string;
+    }): WorkerActorSpec;
+    static uploadToBucket(_spec: WorkerActorSpec, _hub: WorkerStorageHub): Promise<void>;
+    static generateDeployCommands(_spec: WorkerActorSpec, _bucketName: string): CloudRunJobDeployCommands;
+    static generateTaskExecuteCommand(_spec: WorkerActorSpec, _taskId: string): TaskExecuteCommand;
+}

package/dist/deploy/worker-cloud-deployer.js

@@ -0,0 +1,14 @@
+import { SwarmValidationError } from '../errors.js';
+const reason = 'Cloud worker actor deployment is unsupported. Object storage is not a worker executor or the durable daemon store. Use canonical workers through Swarm Orchestrator deployment and approval.';
+/** Compatibility tombstone: never provision a parallel worker runtime. */
+export class WorkerCloudDeployer {
+    static validate(_spec) {
+        return { valid: false, errors: [reason], warnings: [] };
+    }
+    static createDefaultSpec(_params) {
+        throw new SwarmValidationError(reason);
+    }
+    static async uploadToBucket(_spec, _hub) { throw new SwarmValidationError(reason); }
+    static generateDeployCommands(_spec, _bucketName) { throw new SwarmValidationError(reason); }
+    static generateTaskExecuteCommand(_spec, _taskId) { throw new SwarmValidationError(reason); }
+}

package/dist/errors.d.ts

@@ -0,0 +1,36 @@
+export interface SwarmApiErrorOptions {
+    status: number;
+    code?: string;
+    details?: unknown;
+    responseBody?: string;
+}
+export declare class SwarmError extends Error {
+    constructor(message: string);
+}
+export declare class SwarmApiError extends SwarmError {
+    readonly status: number;
+    readonly code?: string;
+    readonly details?: unknown;
+    readonly responseBody?: string;
+    constructor(message: string, options: SwarmApiErrorOptions);
+}
+export declare class SwarmAuthError extends SwarmApiError {
+    constructor(message: string, options: Omit<SwarmApiErrorOptions, 'status'>);
+}
+export declare class SwarmForbiddenError extends SwarmApiError {
+    constructor(message: string, options: Omit<SwarmApiErrorOptions, 'status'>);
+}
+export declare class SwarmNotFoundError extends SwarmApiError {
+    constructor(message: string, options: Omit<SwarmApiErrorOptions, 'status'>);
+}
+export declare class SwarmConflictError extends SwarmApiError {
+    constructor(message: string, options: Omit<SwarmApiErrorOptions, 'status'>);
+}
+export declare class SwarmTimeoutError extends SwarmError {
+    readonly timeoutMs: number;
+    constructor(message: string, timeoutMs: number);
+}
+export declare class SwarmValidationError extends SwarmError {
+    readonly details?: unknown;
+    constructor(message: string, details?: unknown);
+}

package/dist/errors.js

@@ -0,0 +1,68 @@
+export class SwarmError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SwarmError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export class SwarmApiError extends SwarmError {
+    status;
+    code;
+    details;
+    responseBody;
+    constructor(message, options) {
+        super(message);
+        this.name = 'SwarmApiError';
+        this.status = options.status;
+        this.code = options.code;
+        this.details = options.details;
+        this.responseBody = options.responseBody;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export class SwarmAuthError extends SwarmApiError {
+    constructor(message, options) {
+        super(message, { ...options, status: 401 });
+        this.name = 'SwarmAuthError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export class SwarmForbiddenError extends SwarmApiError {
+    constructor(message, options) {
+        super(message, { ...options, status: 403 });
+        this.name = 'SwarmForbiddenError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export class SwarmNotFoundError extends SwarmApiError {
+    constructor(message, options) {
+        super(message, { ...options, status: 404 });
+        this.name = 'SwarmNotFoundError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export class SwarmConflictError extends SwarmApiError {
+    constructor(message, options) {
+        super(message, { ...options, status: 409 });
+        this.name = 'SwarmConflictError';
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export class SwarmTimeoutError extends SwarmError {
+    timeoutMs;
+    constructor(message, timeoutMs) {
+        super(message);
+        this.name = 'SwarmTimeoutError';
+        this.timeoutMs = timeoutMs;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+export class SwarmValidationError extends SwarmError {
+    details;
+    constructor(message, details) {
+        super(message);
+        this.name = 'SwarmValidationError';
+        this.details = details;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export * from './client.js';
+export * from './auth.js';
+export * from './automations.js';
+export * from './workers.js';
+export * from './deliverables.js';
+export * from './deploy/index.js';
+export * from './notifications.js';
+export * from './sessions.js';
+export * from './projects.js';
+export * from './workspaces.js';
+export * from './system.js';
+export * from './transport.js';
+export * from './errors.js';
+export * from './types.js';
+export * from './storage/index.js';
+export { SwarmUsageNamespace } from './usage.js';
+export type { UsageScope, UsageScopeTotal, UsageScopeUpdatedPayload, UsageScopeRepairResult, WorkerBudgetPolicy, WorkerBudgetUpdate, WorkerBudgetStatus } from './usage.js';
+export { SwarmAppsNamespace } from './apps.js';
+export type { ApplicationAgent, ApplicationAgentWrite, ApplicationConversationParams, ApplicationConversationSnapshot } from './apps.js';
+export * from './settings.js';
+export * from './provider-auth.js';
+export * from './realtime.js';
+export type { ApplicationResults, ApplicationResultsOptions } from './app-results.js';