@everruns/sdk 0.1.8 → 0.1.10

package/dist/client.js

@@ -3,17 +3,20 @@
  */
 import { ApiKey } from "./auth.js";
 import { validateAgentName, validateHarnessName, } from "./models.js";
-import { ApiError, AuthenticationError, NotFoundError, RateLimitError, } from "./errors.js";
+import { ApiError, AuthenticationError, NotFoundError, RateLimitError, ValidationError, } from "./errors.js";
 import { EventStream } from "./sse.js";
 export class Everruns {
     apiKey;
     baseUrl;
+    orgId;
     agents;
     sessions;
     messages;
     events;
     capabilities;
-    sessionFiles;
+    workspaces;
+    workspaceFiles;
+    memories;
     connections;
     budgets;
     constructor(options = {}) {
@@ -31,13 +34,19 @@ export class Everruns {
         // Example: "http://host/api/" + "/v1/agents" = "http://host/api//v1/agents" (wrong)
         //          "http://host/api" + "/v1/agents" = "http://host/api/v1/agents" (correct)
         const rawBaseUrl = options.baseUrl ?? "https://custom.example.com/api";
-        this.baseUrl = rawBaseUrl.replace(/\/+$/, "");
+        this.baseUrl = trimTrailingSlashes(rawBaseUrl);
+        const orgId = options.orgId !== undefined
+            ? options.orgId
+            : process.env.EVERRUNS_ORG_ID || undefined;
+        this.orgId = validateOrgId(orgId);
         this.agents = new AgentsClient(this);
         this.sessions = new SessionsClient(this);
         this.messages = new MessagesClient(this);
         this.events = new EventsClient(this);
         this.capabilities = new CapabilitiesClient(this);
-        this.sessionFiles = new SessionFilesClient(this);
+        this.workspaces = new WorkspacesClient(this);
+        this.workspaceFiles = new WorkspaceFilesClient(this);
+        this.memories = new MemoriesClient(this);
         this.connections = new ConnectionsClient(this);
         this.budgets = new BudgetsClient(this);
     }
@@ -45,10 +54,12 @@ export class Everruns {
      * Create a client using environment variables.
      *
      * Reads `EVERRUNS_API_KEY` (required) and `EVERRUNS_API_URL` (optional).
+     * Reads `EVERRUNS_ORG_ID` when present.
      */
     static fromEnv() {
         const baseUrl = process.env.EVERRUNS_API_URL;
-        return new Everruns({ baseUrl });
+        const orgId = process.env.EVERRUNS_ORG_ID || undefined;
+        return new Everruns({ baseUrl, orgId });
     }
     /**
      * Build full URL from a path, adding the /v1 prefix.
@@ -64,8 +75,7 @@ export class Everruns {
         const response = await fetch(url, {
             ...options,
             headers: {
-                Authorization: this.apiKey.toHeader(),
-                "Content-Type": "application/json",
+                ...this.authHeaders("application/json"),
                 ...options.headers,
             },
         });
@@ -95,7 +105,7 @@ export class Everruns {
         const response = await fetch(url, {
             ...options,
             headers: {
-                Authorization: this.apiKey.toHeader(),
+                ...this.authHeaders(),
                 ...options.headers,
             },
         });
@@ -120,6 +130,43 @@ export class Everruns {
     getAuthHeader() {
         return this.apiKey.toHeader();
     }
+    getOrgId() {
+        return this.orgId;
+    }
+    authHeaders(contentType) {
+        const headers = {
+            Authorization: this.apiKey.toHeader(),
+        };
+        if (contentType !== undefined) {
+            headers["Content-Type"] = contentType;
+        }
+        if (this.orgId !== undefined) {
+            headers["X-Org-Id"] = this.orgId;
+        }
+        return headers;
+    }
+}
+function validateOrgId(orgId) {
+    if (orgId === undefined)
+        return undefined;
+    if (orgId.length === 0) {
+        throw new ValidationError("orgId cannot be empty");
+    }
+    try {
+        new Headers({ "X-Org-Id": orgId });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new ValidationError(`Invalid orgId header: ${message}`);
+    }
+    return orgId;
+}
+function trimTrailingSlashes(value) {
+    let end = value.length;
+    while (end > 0 && value.charCodeAt(end - 1) === 47) {
+        end -= 1;
+    }
+    return value.slice(0, end);
 }
 class AgentsClient {
     client;
@@ -165,6 +212,61 @@ class AgentsClient {
     async get(agentId) {
         return this.client.fetch(`/agents/${agentId}`);
     }
+    /** Get aggregate usage stats for an agent. */
+    async stats(agentId) {
+        return this.client.fetch(`/agents/${agentId}/stats`);
+    }
+    /** List recent behavioral health check runs for an agent. */
+    async listHealthChecks(agentId) {
+        return this.client.fetch(`/agents/${agentId}/health-checks`);
+    }
+    /** Trigger a behavioral health check for an agent. */
+    async triggerHealthCheck(agentId) {
+        return this.client.fetch(`/agents/${agentId}/health-checks`, {
+            method: "POST",
+        });
+    }
+    /** Get a single health check run for an agent. */
+    async getHealthCheck(agentId, runId) {
+        return this.client.fetch(`/agents/${agentId}/health-checks/${runId}`);
+    }
+    /** List saved versions for an agent. */
+    async listVersions(agentId) {
+        return this.client.fetch(`/agents/${agentId}/versions`);
+    }
+    /** Save the current agent configuration as a version. */
+    async createVersion(agentId, request = {}) {
+        return this.client.fetch(`/agents/${agentId}/versions`, {
+            method: "POST",
+            body: JSON.stringify(toCreateAgentVersionBody(request)),
+        });
+    }
+    /** Set the default version for an agent. */
+    async setDefaultVersion(agentId, request) {
+        return this.client.fetch(`/agents/${agentId}/versions/default`, {
+            method: "POST",
+            body: JSON.stringify({ version_id: request.versionId }),
+        });
+    }
+    /** Diff two saved agent versions. */
+    async diffVersions(agentId, fromVersionId, toVersionId) {
+        return this.client.fetch(`/agents/${agentId}/versions/${fromVersionId}/diff/${toVersionId}`);
+    }
+    /** Create a new agent from a saved version. */
+    async forkVersion(agentId, versionId, request) {
+        validateAgentName(request.name);
+        return this.client.fetch(`/agents/${agentId}/versions/${versionId}/fork`, {
+            method: "POST",
+            body: JSON.stringify(toForkAgentVersionBody(request)),
+        });
+    }
+    /** Restore an agent from a saved version. */
+    async rollbackVersion(agentId, versionId, request = {}) {
+        return this.client.fetch(`/agents/${agentId}/versions/${versionId}/rollback`, {
+            method: "POST",
+            body: JSON.stringify(toRollbackAgentVersionBody(request)),
+        });
+    }
     async list(options) {
         const query = options?.search
             ? `?search=${encodeURIComponent(options.search)}`
@@ -201,6 +303,18 @@ class AgentsClient {
     async export(agentId) {
         return this.client.fetchText(`/agents/${agentId}/export`);
     }
+    /** Run advisory checks against an agent shape. */
+    async analyze(request) {
+        return this.client.fetch("/agents/analyze", {
+            method: "POST",
+            body: JSON.stringify({
+                system_prompt: request.systemPrompt,
+                capabilities: request.capabilities ?? [],
+                tools: request.tools ?? [],
+                mcpServers: request.mcpServers,
+            }),
+        });
+    }
 }
 class SessionsClient {
     client;
@@ -239,6 +353,9 @@ class SessionsClient {
         if (request.capabilities?.length) {
             body.capabilities = request.capabilities;
         }
+        if (request.tools?.length) {
+            body.tools = request.tools;
+        }
         if (request.initialFiles !== undefined) {
             body.initial_files = request.initialFiles.map((file) => ({
                 path: file.path,
@@ -335,23 +452,52 @@ class MessagesClient {
     /**
      * Send tool results back to the session.
      *
-     * Use after receiving tool calls from an `output.message.completed`
+     * Use after receiving tool calls from a `tool.call_requested`
      * event to provide results from locally-executed tools.
      */
     async createToolResults(sessionId, results) {
-        const request = {
-            message: { role: "tool_result", content: results },
-        };
-        return this.client.fetch(`/sessions/${sessionId}/messages`, {
-            method: "POST",
-            body: JSON.stringify(request),
+        const toolResults = results.map((part) => {
+            if (part.type !== "tool_result" || !part.tool_call_id) {
+                throw new Error("createToolResults accepts only tool_result content parts");
+            }
+            return {
+                tool_call_id: part.tool_call_id,
+                result: part.result,
+                error: part.error,
+            };
         });
+        const body = JSON.stringify({ tool_results: toolResults });
+        let delay = 100;
+        for (let attempt = 0; attempt <= 5; attempt++) {
+            try {
+                return await this.client.fetch(`/sessions/${sessionId}/tool-results`, {
+                    method: "POST",
+                    body,
+                });
+            }
+            catch (error) {
+                if (attempt >= 5 || !isToolResultsPendingConflict(error)) {
+                    throw error;
+                }
+                await sleep(delay);
+                delay *= 2;
+            }
+        }
+        throw new Error("unreachable");
     }
     async list(sessionId) {
         const response = await this.client.fetch(`/sessions/${sessionId}/messages`);
         return response.messages;
     }
 }
+function isToolResultsPendingConflict(error) {
+    return (error instanceof ApiError &&
+        error.statusCode === 409 &&
+        String(error.body).includes("not waiting for tool results"));
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 class EventsClient {
     client;
     constructor(client) {
@@ -375,9 +521,36 @@ class EventsClient {
             params.set("limit", String(options.limit));
         if (options?.beforeSequence != null)
             params.set("before_sequence", String(options.beforeSequence));
+        if (options?.afterSequence != null)
+            params.set("after_sequence", String(options.afterSequence));
+        if (options?.around)
+            params.set("around", options.around);
+        if (options?.window != null)
+            params.set("window", String(options.window));
+        if (options?.fromTs)
+            params.set("from_ts", options.fromTs);
+        if (options?.toTs)
+            params.set("to_ts", options.toTs);
+        if (options?.turnId)
+            params.set("turn_id", options.turnId);
+        if (options?.execId)
+            params.set("exec_id", options.execId);
+        if (options?.traceId)
+            params.set("trace_id", options.traceId);
+        if (options?.tags) {
+            for (const tag of options.tags) {
+                params.append("tags", tag);
+            }
+        }
+        if (options?.toolName)
+            params.set("tool_name", options.toolName);
+        if (options?.q)
+            params.set("q", options.q);
+        if (options?.orderDesc !== undefined)
+            params.set("order_desc", String(options.orderDesc));
         const query = params.toString() ? `?${params}` : "";
         const response = await this.client.fetch(`/sessions/${sessionId}/events${query}`);
-        return response.events;
+        return response.data;
     }
     /**
      * Stream events from a session via SSE with automatic reconnection.
@@ -402,7 +575,7 @@ class EventsClient {
     stream(sessionId, options) {
         // Build base URL (without since_id - EventStream handles that for reconnection)
         const url = this.client.getStreamUrl(`/sessions/${sessionId}/sse`);
-        return new EventStream(url, this.client.getAuthHeader(), options);
+        return new EventStream(url, this.client.getAuthHeader(), options, this.client.getOrgId());
     }
 }
 class CapabilitiesClient {
@@ -421,89 +594,258 @@ class CapabilitiesClient {
             params.set("limit", String(options.limit));
         const query = params.toString() ? `?${params.toString()}` : "";
         const response = await this.client.fetch(`/capabilities${query}`);
-        return { data: response.data, total: response.total ?? 0, offset: response.offset ?? 0, limit: response.limit ?? 0 };
+        return {
+            data: response.data,
+            total: response.total ?? 0,
+            offset: response.offset ?? 0,
+            limit: response.limit ?? 0,
+        };
     }
     /** Get a specific capability by ID. */
     async get(capabilityId) {
         return this.client.fetch(`/capabilities/${capabilityId}`);
     }
+    /** List adoptable guardrail presets. */
+    async listGuardrailExamples() {
+        return this.client.fetch("/capabilities/guardrails/examples");
+    }
+    /** Evaluate a guardrails config against sample content. */
+    async dryRunGuardrails(request) {
+        return this.client.fetch("/capabilities/guardrails/dry-run", {
+            method: "POST",
+            body: JSON.stringify({
+                config: request.config,
+                stage: request.stage,
+                text: request.text,
+                tool_name: request.toolName,
+            }),
+        });
+    }
+}
+class WorkspacesClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /** List workspaces. */
+    async list(options) {
+        const params = new URLSearchParams();
+        if (options?.search)
+            params.set("search", options.search);
+        if (options?.includeArchived != null) {
+            params.set("include_archived", String(options.includeArchived));
+        }
+        const query = params.toString() ? `?${params}` : "";
+        const response = await this.client.fetch(`/workspaces${query}`);
+        return response.data;
+    }
+    /** Create a workspace. */
+    async create(request) {
+        return this.client.fetch("/workspaces", {
+            method: "POST",
+            body: JSON.stringify(request),
+        });
+    }
+    /** Get a workspace by ID. */
+    async get(workspaceId) {
+        return this.client.fetch(`/workspaces/${workspaceId}`);
+    }
+    /** Update a workspace. */
+    async update(workspaceId, request) {
+        return this.client.fetch(`/workspaces/${workspaceId}`, {
+            method: "PATCH",
+            body: JSON.stringify(request),
+        });
+    }
+    /** Archive a workspace. */
+    async delete(workspaceId) {
+        await this.client.fetch(`/workspaces/${workspaceId}`, { method: "DELETE" });
+    }
 }
-class SessionFilesClient {
+class WorkspaceFilesClient {
     client;
     constructor(client) {
         this.client = client;
     }
     /** List files in a directory. */
-    async list(sessionId, options) {
+    async list(workspaceId, options) {
         const fsPath = options?.path
-            ? `/sessions/${sessionId}/fs/${options.path.replace(/^\//, "")}`
-            : `/sessions/${sessionId}/fs`;
+            ? `/workspaces/${workspaceId}/fs/${options.path.replace(/^\//, "")}`
+            : `/workspaces/${workspaceId}/fs`;
         const params = new URLSearchParams();
         if (options?.recursive)
             params.set("recursive", "true");
         const query = params.toString() ? `?${params}` : "";
         const response = await this.client.fetch(`${fsPath}${query}`);
-        return { data: response.data, total: response.total ?? 0, offset: response.offset ?? 0, limit: response.limit ?? 0 };
+        return {
+            data: response.data,
+            total: response.total ?? 0,
+            offset: response.offset ?? 0,
+            limit: response.limit ?? 0,
+        };
     }
     /** Read a file's content. */
-    async read(sessionId, path) {
-        return this.client.fetch(`/sessions/${sessionId}/fs/${path.replace(/^\//, "")}`);
+    async read(workspaceId, path) {
+        return this.client.fetch(`/workspaces/${workspaceId}/fs/${path.replace(/^\//, "")}`);
     }
     /** Create a file. */
-    async create(sessionId, path, content, options) {
+    async create(workspaceId, path, content, options) {
         const body = { content };
         if (options?.encoding)
             body.encoding = options.encoding;
         if (options?.isReadonly != null)
             body.is_readonly = options.isReadonly;
-        return this.client.fetch(`/sessions/${sessionId}/fs/${path.replace(/^\//, "")}`, { method: "POST", body: JSON.stringify(body) });
+        return this.client.fetch(`/workspaces/${workspaceId}/fs/${path.replace(/^\//, "")}`, { method: "POST", body: JSON.stringify(body) });
     }
     /** Create a directory. */
-    async createDir(sessionId, path) {
-        return this.client.fetch(`/sessions/${sessionId}/fs/${path.replace(/^\//, "")}`, { method: "POST", body: JSON.stringify({ is_directory: true }) });
+    async createDir(workspaceId, path) {
+        return this.client.fetch(`/workspaces/${workspaceId}/fs/${path.replace(/^\//, "")}`, { method: "POST", body: JSON.stringify({ is_directory: true }) });
     }
     /** Update a file's content. */
-    async update(sessionId, path, content, options) {
+    async update(workspaceId, path, content, options) {
         const body = { content };
         if (options?.encoding)
             body.encoding = options.encoding;
         if (options?.isReadonly != null)
             body.is_readonly = options.isReadonly;
-        return this.client.fetch(`/sessions/${sessionId}/fs/${path.replace(/^\//, "")}`, { method: "PUT", body: JSON.stringify(body) });
+        return this.client.fetch(`/workspaces/${workspaceId}/fs/${path.replace(/^\//, "")}`, { method: "PUT", body: JSON.stringify(body) });
     }
     /** Delete a file or directory. */
-    async delete(sessionId, path, options) {
+    async delete(workspaceId, path, options) {
         const params = new URLSearchParams();
         if (options?.recursive)
             params.set("recursive", "true");
         const query = params.toString() ? `?${params}` : "";
-        return this.client.fetch(`/sessions/${sessionId}/fs/${path.replace(/^\//, "")}${query}`, { method: "DELETE" });
+        return this.client.fetch(`/workspaces/${workspaceId}/fs/${path.replace(/^\//, "")}${query}`, { method: "DELETE" });
     }
     /** Move/rename a file. */
-    async moveFile(sessionId, srcPath, dstPath) {
-        return this.client.fetch(`/sessions/${sessionId}/fs/_/move`, {
+    async moveFile(workspaceId, srcPath, dstPath) {
+        return this.client.fetch(`/workspaces/${workspaceId}/fs/_/move`, {
             method: "POST",
             body: JSON.stringify({ src_path: srcPath, dst_path: dstPath }),
         });
     }
     /** Copy a file. */
-    async copyFile(sessionId, srcPath, dstPath) {
-        return this.client.fetch(`/sessions/${sessionId}/fs/_/copy`, {
+    async copyFile(workspaceId, srcPath, dstPath) {
+        return this.client.fetch(`/workspaces/${workspaceId}/fs/_/copy`, {
             method: "POST",
             body: JSON.stringify({ src_path: srcPath, dst_path: dstPath }),
         });
     }
     /** Search files with regex. */
-    async grep(sessionId, pattern, options) {
+    async grep(workspaceId, pattern, options) {
         const body = { pattern };
         if (options?.pathPattern)
             body.path_pattern = options.pathPattern;
-        const response = await this.client.fetch(`/sessions/${sessionId}/fs/_/grep`, { method: "POST", body: JSON.stringify(body) });
+        const response = await this.client.fetch(`/workspaces/${workspaceId}/fs/_/grep`, { method: "POST", body: JSON.stringify(body) });
         return response.data;
     }
     /** Get file or directory stat. */
-    async stat(sessionId, path) {
-        return this.client.fetch(`/sessions/${sessionId}/fs/_/stat`, {
+    async stat(workspaceId, path) {
+        return this.client.fetch(`/workspaces/${workspaceId}/fs/_/stat`, {
+            method: "POST",
+            body: JSON.stringify({ path }),
+        });
+    }
+}
+class MemoriesClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /** List memories. */
+    async list(options) {
+        const params = new URLSearchParams();
+        if (options?.search)
+            params.set("search", options.search);
+        if (options?.includeArchived != null) {
+            params.set("include_archived", String(options.includeArchived));
+        }
+        const query = params.toString() ? `?${params}` : "";
+        const response = await this.client.fetch(`/memories${query}`);
+        return response.data;
+    }
+    /** Create a memory. */
+    async create(request) {
+        return this.client.fetch("/memories", {
+            method: "POST",
+            body: JSON.stringify(request),
+        });
+    }
+    /** Get a memory by ID. */
+    async get(memoryId) {
+        return this.client.fetch(`/memories/${memoryId}`);
+    }
+    /** Update a memory. */
+    async update(memoryId, request) {
+        return this.client.fetch(`/memories/${memoryId}`, {
+            method: "PATCH",
+            body: JSON.stringify(request),
+        });
+    }
+    /** Archive a memory. */
+    async delete(memoryId) {
+        await this.client.fetch(`/memories/${memoryId}`, { method: "DELETE" });
+    }
+    /** Trigger memory sync now. */
+    async sync(memoryId) {
+        return this.client.fetch(`/memories/${memoryId}/sync`, {
+            method: "POST",
+        });
+    }
+    /** List memory files at the root. */
+    async listFiles(memoryId) {
+        const response = await this.client.fetch(`/memories/${memoryId}/fs`);
+        return response.data;
+    }
+    /** Read a memory file. */
+    async readFile(memoryId, path) {
+        return this.client.fetch(`/memories/${memoryId}/fs/${path.replace(/^\//, "")}`);
+    }
+    /** Download a memory file as text. */
+    async downloadFile(memoryId, path) {
+        return this.client.fetchText(`/memories/${memoryId}/fs/_/download/${path.replace(/^\//, "")}`);
+    }
+    /** Create a memory file. */
+    async createFile(memoryId, path, request) {
+        return this.client.fetch(`/memories/${memoryId}/fs/${path.replace(/^\//, "")}`, {
+            method: "POST",
+            body: JSON.stringify({
+                content: request.content,
+                encoding: request.encoding,
+                is_directory: request.isDirectory,
+            }),
+        });
+    }
+    /** Create a memory directory. */
+    async createDir(memoryId, path) {
+        return this.createFile(memoryId, path, { isDirectory: true });
+    }
+    /** Update a memory file. */
+    async updateFile(memoryId, path, request) {
+        return this.client.fetch(`/memories/${memoryId}/fs/${path.replace(/^\//, "")}`, {
+            method: "PUT",
+            body: JSON.stringify({
+                content: request.content,
+                encoding: request.encoding,
+            }),
+        });
+    }
+    /** Delete a memory file or directory. */
+    async deleteFile(memoryId, path) {
+        await this.client.fetch(`/memories/${memoryId}/fs/${path.replace(/^\//, "")}`, { method: "DELETE" });
+    }
+    /** Search memory files by regex. */
+    async grepFiles(memoryId, pattern, options) {
+        const body = { pattern };
+        if (options?.pathPattern)
+            body.path_pattern = options.pathPattern;
+        const response = await this.client.fetch(`/memories/${memoryId}/fs/_/grep`, { method: "POST", body: JSON.stringify(body) });
+        return response.data;
+    }
+    /** Stat a memory file or directory. */
+    async statFile(memoryId, path) {
+        return this.client.fetch(`/memories/${memoryId}/fs/_/stat`, {
             method: "POST",
             body: JSON.stringify({ path }),
         });
@@ -621,6 +963,9 @@ function toAgentBody(request) {
     if (request.capabilities?.length) {
         body.capabilities = request.capabilities;
     }
+    if (request.tools?.length) {
+        body.tools = request.tools;
+    }
     if (request.initialFiles?.length) {
         body.initial_files = request.initialFiles.map((file) => ({
             path: file.path,
@@ -631,6 +976,36 @@ function toAgentBody(request) {
     }
     return body;
 }
+function toCreateAgentVersionBody(request) {
+    const body = {};
+    if (request.changeKind !== undefined) {
+        body.change_kind = request.changeKind;
+    }
+    if (request.summary !== undefined) {
+        body.summary = request.summary;
+    }
+    return body;
+}
+function toForkAgentVersionBody(request) {
+    const body = { name: request.name };
+    if (request.displayName !== undefined) {
+        body.display_name = request.displayName;
+    }
+    if (request.description !== undefined) {
+        body.description = request.description;
+    }
+    return body;
+}
+function toRollbackAgentVersionBody(request) {
+    const body = {};
+    if (request.saveVersion !== undefined) {
+        body.save_version = request.saveVersion;
+    }
+    if (request.summary !== undefined) {
+        body.summary = request.summary;
+    }
+    return body;
+}
 /** Check if the body looks like an HTML response */
 function isHtmlResponse(body) {
     const trimmed = body.trimStart();