@prisme.ai/sdk 1.0.2 → 2.0.1

package/dist/index.js

@@ -0,0 +1,1326 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuthenticationError: () => AuthenticationError,
+  ConflictError: () => ConflictError,
+  ConnectionError: () => ConnectionError,
+  InternalServerError: () => InternalServerError,
+  NotFoundError: () => NotFoundError,
+  PageIterator: () => PageIterator,
+  PermissionDeniedError: () => PermissionDeniedError,
+  PrismeAI: () => PrismeAI,
+  PrismeAIError: () => PrismeAIError,
+  RateLimitError: () => RateLimitError,
+  SSEStream: () => SSEStream,
+  TimeoutError: () => TimeoutError,
+  ValidationError: () => ValidationError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/errors.ts
+var PrismeAIError = class extends Error {
+  status;
+  headers;
+  body;
+  constructor(message, { status, headers, body } = {}) {
+    super(message);
+    this.name = "PrismeAIError";
+    this.status = status;
+    this.headers = headers;
+    this.body = body;
+  }
+};
+var AuthenticationError = class extends PrismeAIError {
+  status = 401;
+  constructor(message, opts) {
+    super(message, { status: 401, ...opts });
+    this.name = "AuthenticationError";
+  }
+};
+var PermissionDeniedError = class extends PrismeAIError {
+  status = 403;
+  constructor(message, opts) {
+    super(message, { status: 403, ...opts });
+    this.name = "PermissionDeniedError";
+  }
+};
+var NotFoundError = class extends PrismeAIError {
+  status = 404;
+  constructor(message, opts) {
+    super(message, { status: 404, ...opts });
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends PrismeAIError {
+  status = 409;
+  constructor(message, opts) {
+    super(message, { status: 409, ...opts });
+    this.name = "ConflictError";
+  }
+};
+var ValidationError = class extends PrismeAIError {
+  status = 422;
+  constructor(message, opts) {
+    super(message, { status: 422, ...opts });
+    this.name = "ValidationError";
+  }
+};
+var RateLimitError = class extends PrismeAIError {
+  status = 429;
+  retryAfter;
+  constructor(message, opts) {
+    super(message, { status: 429, ...opts });
+    this.name = "RateLimitError";
+    this.retryAfter = opts?.headers ? parseRetryAfter(opts.headers.get("retry-after")) : void 0;
+  }
+};
+var InternalServerError = class extends PrismeAIError {
+  status = 500;
+  constructor(message, opts) {
+    super(message, { status: 500, ...opts });
+    this.name = "InternalServerError";
+  }
+};
+var ConnectionError = class extends PrismeAIError {
+  constructor(message) {
+    super(message);
+    this.name = "ConnectionError";
+  }
+};
+var TimeoutError = class extends PrismeAIError {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+function parseRetryAfter(value) {
+  if (!value) return void 0;
+  const seconds = Number(value);
+  if (!Number.isNaN(seconds)) return seconds * 1e3;
+  const date = Date.parse(value);
+  if (!Number.isNaN(date)) return date - Date.now();
+  return void 0;
+}
+function errorFromStatus(status, message, headers, body) {
+  const opts = { headers, body };
+  switch (status) {
+    case 401:
+      return new AuthenticationError(message, opts);
+    case 403:
+      return new PermissionDeniedError(message, opts);
+    case 404:
+      return new NotFoundError(message, opts);
+    case 409:
+      return new ConflictError(message, opts);
+    case 422:
+      return new ValidationError(message, opts);
+    case 429:
+      return new RateLimitError(message, opts);
+    default:
+      if (status >= 500) return new InternalServerError(message, opts);
+      return new PrismeAIError(message, { status, ...opts });
+  }
+}
+
+// src/core/http-client.ts
+var DEFAULT_TIMEOUT = 6e4;
+var DEFAULT_MAX_RETRIES = 2;
+var RETRY_STATUS_CODES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var INITIAL_RETRY_DELAY = 500;
+var MAX_RETRY_DELAY = 8e3;
+var HttpClient = class {
+  baseURL;
+  defaultHeaders;
+  timeout;
+  maxRetries;
+  constructor(options) {
+    this.baseURL = options.baseURL.replace(/\/+$/, "");
+    this.defaultHeaders = options.headers;
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+  }
+  async request(options) {
+    const url = this.buildURL(options.path, options.query);
+    const headers = {
+      ...this.defaultHeaders,
+      ...options.headers
+    };
+    if (options.body !== void 0 && !headers["content-type"]) {
+      headers["content-type"] = "application/json";
+    }
+    const fetchOptions = {
+      method: options.method,
+      headers,
+      signal: options.signal
+    };
+    if (options.body !== void 0) {
+      if (options.body instanceof FormData) {
+        delete headers["content-type"];
+        fetchOptions.body = options.body;
+      } else {
+        fetchOptions.body = JSON.stringify(options.body);
+      }
+    }
+    const timeout = options.timeout ?? this.timeout;
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      if (attempt > 0) {
+        const delay = this.getRetryDelay(attempt, lastError);
+        await sleep(delay);
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      if (options.signal) {
+        options.signal.addEventListener("abort", () => controller.abort(), { once: true });
+      }
+      try {
+        const response = await fetch(url, {
+          ...fetchOptions,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (response.ok) {
+          if (options.raw) return response;
+          const text = await response.text();
+          if (!text) return void 0;
+          try {
+            return JSON.parse(text);
+          } catch {
+            return text;
+          }
+        }
+        const body = await this.safeParseBody(response);
+        const message = extractErrorMessage(body, response.statusText);
+        const error = errorFromStatus(response.status, message, response.headers, body);
+        if (RETRY_STATUS_CODES.has(response.status) && attempt < this.maxRetries) {
+          lastError = error;
+          continue;
+        }
+        throw error;
+      } catch (err) {
+        clearTimeout(timeoutId);
+        if (err instanceof PrismeAIError) throw err;
+        if (err instanceof DOMException && err.name === "AbortError") {
+          if (options.signal?.aborted) {
+            throw new PrismeAIError("Request aborted");
+          }
+          throw new TimeoutError(`Request timed out after ${timeout}ms`);
+        }
+        if (attempt < this.maxRetries) {
+          lastError = new ConnectionError(
+            err instanceof Error ? err.message : "Connection failed"
+          );
+          continue;
+        }
+        throw new ConnectionError(
+          err instanceof Error ? err.message : "Connection failed"
+        );
+      }
+    }
+    throw lastError ?? new PrismeAIError("Request failed after retries");
+  }
+  async requestRaw(options) {
+    return this.request({ ...options, raw: true });
+  }
+  get(path, query, options) {
+    return this.request({ method: "GET", path, query, ...options });
+  }
+  post(path, body, options) {
+    return this.request({ method: "POST", path, body, ...options });
+  }
+  put(path, body, options) {
+    return this.request({ method: "PUT", path, body, ...options });
+  }
+  patch(path, body, options) {
+    return this.request({ method: "PATCH", path, body, ...options });
+  }
+  delete(path, query, options) {
+    return this.request({ method: "DELETE", path, query, ...options });
+  }
+  buildURL(path, query) {
+    const url = new URL(path, this.baseURL + "/");
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  getRetryDelay(attempt, lastError) {
+    if (lastError instanceof RateLimitError && lastError.retryAfter) {
+      return Math.min(lastError.retryAfter, MAX_RETRY_DELAY);
+    }
+    const base = INITIAL_RETRY_DELAY * Math.pow(2, attempt - 1);
+    const jitter = base * 0.2 * Math.random();
+    return Math.min(base + jitter, MAX_RETRY_DELAY);
+  }
+  async safeParseBody(response) {
+    try {
+      const text = await response.text();
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    } catch {
+      return void 0;
+    }
+  }
+};
+function extractErrorMessage(body, fallback) {
+  if (body && typeof body === "object") {
+    const obj = body;
+    if (typeof obj.message === "string") return obj.message;
+    if (typeof obj.error === "string") return obj.error;
+    if (obj.error && typeof obj.error === "object") {
+      const inner = obj.error;
+      if (typeof inner.message === "string") return inner.message;
+    }
+  }
+  return fallback;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/core/pagination.ts
+var PageIterator = class {
+  httpClient;
+  options;
+  pageSize;
+  currentPage;
+  extractData;
+  constructor(httpClient, options, extractData, pageSize = 20, startPage = 1) {
+    this.httpClient = httpClient;
+    this.options = options;
+    this.extractData = extractData;
+    this.pageSize = pageSize;
+    this.currentPage = startPage;
+  }
+  /**
+   * Fetch a specific page.
+   */
+  async getPage(page) {
+    const targetPage = page ?? this.currentPage;
+    const query = {
+      ...this.options.query,
+      page: targetPage,
+      limit: this.pageSize
+    };
+    const raw = await this.httpClient.request({
+      ...this.options,
+      query
+    });
+    return this.extractData(raw);
+  }
+  /**
+   * Collect all items across all pages into a single array.
+   */
+  async toArray() {
+    const items = [];
+    for await (const item of this) {
+      items.push(item);
+    }
+    return items;
+  }
+  async *[Symbol.asyncIterator]() {
+    let page = this.currentPage;
+    while (true) {
+      const result = await this.getPage(page);
+      for (const item of result.data) {
+        yield item;
+      }
+      if (result.data.length < this.pageSize || result.hasMore === false) {
+        break;
+      }
+      page++;
+    }
+  }
+};
+function defaultExtractor(body) {
+  if (Array.isArray(body)) {
+    return { data: body, hasMore: false };
+  }
+  const obj = body;
+  const data = obj.results ?? obj.data ?? obj.items ?? obj.documents ?? [];
+  const total = obj.total;
+  const page = obj.page;
+  const limit = obj.limit;
+  let hasMore;
+  if (total !== void 0 && page !== void 0 && limit !== void 0) {
+    hasMore = page * limit < total;
+  } else if (obj.hasMore !== void 0) {
+    hasMore = obj.hasMore;
+  }
+  return { data, total, page, limit, hasMore };
+}
+
+// src/core/base-resource.ts
+var BaseResource = class {
+  httpClient;
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  _get(path, query) {
+    return this.httpClient.get(path, query);
+  }
+  _post(path, body, options) {
+    return this.httpClient.post(path, body, options);
+  }
+  _put(path, body) {
+    return this.httpClient.put(path, body);
+  }
+  _patch(path, body) {
+    return this.httpClient.patch(path, body);
+  }
+  _del(path, query) {
+    return this.httpClient.delete(path, query);
+  }
+  _paginate(path, query, pagination, extractor) {
+    return new PageIterator(
+      this.httpClient,
+      {
+        method: "GET",
+        path,
+        query: { ...query }
+      },
+      extractor ?? defaultExtractor,
+      pagination?.limit ?? 20,
+      pagination?.page ?? 1
+    );
+  }
+  /**
+   * Build a path with workspace ID prefix.
+   */
+  buildPath(workspaceId, ...segments) {
+    return `/workspaces/${workspaceId}/webhooks/${segments.join("/")}`;
+  }
+};
+
+// src/core/streaming.ts
+var SSEStream = class {
+  response;
+  controller;
+  _done = false;
+  constructor(response, controller) {
+    this.response = response;
+    this.controller = controller;
+  }
+  get done() {
+    return this._done;
+  }
+  abort() {
+    this.controller.abort();
+    this._done = true;
+  }
+  async *[Symbol.asyncIterator]() {
+    const body = this.response.body;
+    if (!body) {
+      this._done = true;
+      return;
+    }
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          if (buffer.trim()) {
+            const event = parseSSEBlock(buffer);
+            if (event !== null) {
+              yield event;
+            }
+          }
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const events = extractSSEEvents(buffer);
+        buffer = events.remaining;
+        for (const event of events.parsed) {
+          if (event !== null) {
+            yield event;
+          }
+        }
+      }
+    } catch (err) {
+      if (this.controller.signal.aborted) return;
+      throw err;
+    } finally {
+      this._done = true;
+      reader.releaseLock();
+    }
+  }
+};
+function extractSSEEvents(buffer) {
+  const parsed = [];
+  const blocks = buffer.split(/\n\n/);
+  const remaining = blocks.pop() ?? "";
+  for (const block of blocks) {
+    const event = parseSSEBlock(block);
+    if (event !== null) {
+      parsed.push(event);
+    }
+  }
+  return { parsed, remaining };
+}
+function parseSSEBlock(block) {
+  let data = "";
+  let eventType = "";
+  for (const line of block.split("\n")) {
+    if (line.startsWith("data:")) {
+      const value = line.slice(5).trimStart();
+      data += (data ? "\n" : "") + value;
+    } else if (line.startsWith("event:")) {
+      eventType = line.slice(6).trimStart();
+    }
+  }
+  if (!data) return null;
+  if (data === "[DONE]") return null;
+  try {
+    const parsed = JSON.parse(data);
+    if (eventType) {
+      parsed.__event = eventType;
+    }
+    return parsed;
+  } catch {
+    return { data, event: eventType || void 0 };
+  }
+}
+
+// src/resources/agents/messages.ts
+var Messages = class extends BaseResource {
+  workspaceId;
+  constructor(httpClient, workspaceId) {
+    super(httpClient);
+    this.workspaceId = workspaceId;
+  }
+  path(...segments) {
+    return this.buildPath(this.workspaceId, ...segments);
+  }
+  /** Send a message to an agent and get a complete response. */
+  send(agentId, params) {
+    return this._post(this.path("agents", agentId, "messages"), params);
+  }
+  /** Send a message and receive the response as an SSE stream. */
+  async stream(agentId, params) {
+    const controller = new AbortController();
+    const response = await this.httpClient.requestRaw({
+      method: "POST",
+      path: this.path("agents", agentId, "messages", "stream"),
+      body: params,
+      headers: {
+        accept: "text/event-stream"
+      },
+      signal: controller.signal
+    });
+    return new SSEStream(response, controller);
+  }
+};
+
+// src/resources/agents/conversations.ts
+var Conversations = class extends BaseResource {
+  workspaceId;
+  constructor(httpClient, workspaceId) {
+    super(httpClient);
+    this.workspaceId = workspaceId;
+  }
+  path(...segments) {
+    return this.buildPath(this.workspaceId, ...segments);
+  }
+  /** List conversations. */
+  list(params) {
+    return this._paginate(this.path("conversations"), params);
+  }
+  /** Create a new conversation. */
+  create(params) {
+    return this._post(this.path("conversations"), params);
+  }
+  /** Get a conversation by ID. */
+  get(conversationId) {
+    return this.httpClient.get(this.path("conversations", conversationId));
+  }
+  /** Update a conversation. */
+  update(conversationId, params) {
+    return this._patch(this.path("conversations", conversationId), params);
+  }
+  /** Delete a conversation. */
+  delete(conversationId) {
+    return this._del(this.path("conversations", conversationId));
+  }
+  /** List messages in a conversation. */
+  messages(conversationId, params) {
+    return this._paginate(
+      this.path("conversations", conversationId, "messages"),
+      params
+    );
+  }
+  /** Share a conversation. */
+  share(conversationId, params) {
+    return this._post(this.path("conversations", conversationId, "share"), params);
+  }
+};
+
+// src/resources/agents/tools.ts
+var Tools = class extends BaseResource {
+  workspaceId;
+  constructor(httpClient, workspaceId) {
+    super(httpClient);
+    this.workspaceId = workspaceId;
+  }
+  path(...segments) {
+    return this.buildPath(this.workspaceId, ...segments);
+  }
+  /** List tools available for agents. */
+  list(params) {
+    return this._paginate(this.path("tools"), params);
+  }
+  /** Create a new tool. */
+  create(params) {
+    return this._post(this.path("tools"), params);
+  }
+  /** Get a tool by ID. */
+  get(toolId) {
+    return this.httpClient.get(this.path("tools", toolId));
+  }
+};
+
+// src/resources/agents/access.ts
+var Access = class extends BaseResource {
+  workspaceId;
+  constructor(httpClient, workspaceId) {
+    super(httpClient);
+    this.workspaceId = workspaceId;
+  }
+  path(...segments) {
+    return this.buildPath(this.workspaceId, ...segments);
+  }
+  /** List access entries for an agent. */
+  list(agentId, params) {
+    return this._paginate(this.path("agents", agentId, "access"), params);
+  }
+  /** Grant access to an agent. */
+  grant(agentId, params) {
+    return this._post(this.path("agents", agentId, "access"), params);
+  }
+  /** Revoke access to an agent. */
+  revoke(agentId, accessId) {
+    return this._del(this.path("agents", agentId, "access", accessId));
+  }
+  /** Request access to an agent. */
+  requestAccess(agentId) {
+    return this._post(this.path("agents", agentId, "access-requests"));
+  }
+  /** List access requests for an agent. */
+  listRequests(agentId, params) {
+    return this._paginate(this.path("agents", agentId, "access-requests"), params);
+  }
+  /** Handle an access request (approve/reject). */
+  handleRequest(agentId, requestId, params) {
+    return this._post(
+      this.path("agents", agentId, "access-requests", requestId, params.action)
+    );
+  }
+};
+
+// src/resources/agents/analytics.ts
+var Analytics = class extends BaseResource {
+  workspaceId;
+  constructor(httpClient, workspaceId) {
+    super(httpClient);
+    this.workspaceId = workspaceId;
+  }
+  path(...segments) {
+    return this.buildPath(this.workspaceId, ...segments);
+  }
+  /** Get analytics for an agent. */
+  get(agentId, params) {
+    return this.httpClient.get(this.path("agents", agentId, "analytics"), params);
+  }
+};
+
+// src/resources/agents/evaluations.ts
+var Evaluations = class extends BaseResource {
+  workspaceId;
+  constructor(httpClient, workspaceId) {
+    super(httpClient);
+    this.workspaceId = workspaceId;
+  }
+  path(...segments) {
+    return this.buildPath(this.workspaceId, ...segments);
+  }
+  /** List evaluations for an agent. */
+  list(agentId, params) {
+    return this._paginate(this.path("agents", agentId, "evaluations"), params);
+  }
+  /** Create a new evaluation. */
+  create(agentId, params) {
+    return this._post(this.path("agents", agentId, "evaluations"), params);
+  }
+};
+
+// src/resources/agents/a2a.ts
+var A2A = class extends BaseResource {
+  workspaceId;
+  constructor(httpClient, workspaceId) {
+    super(httpClient);
+    this.workspaceId = workspaceId;
+  }
+  path(...segments) {
+    return this.buildPath(this.workspaceId, ...segments);
+  }
+  /** Send a message via A2A protocol. */
+  send(agentId, params) {
+    return this._post(this.path("agents", agentId, "a2a", "send"), params);
+  }
+  /** Send a message and subscribe to SSE events (A2A protocol). */
+  async sendSubscribe(agentId, params) {
+    const controller = new AbortController();
+    const response = await this.httpClient.requestRaw({
+      method: "POST",
+      path: this.path("agents", agentId, "a2a", "send-subscribe"),
+      body: params,
+      headers: {
+        accept: "text/event-stream"
+      },
+      signal: controller.signal
+    });
+    return new SSEStream(response, controller);
+  }
+  /** Get the A2A agent card. */
+  getCard(agentId) {
+    return this.httpClient.get(this.path("agents", agentId, "a2a", "card"));
+  }
+  /** Get the extended A2A agent card with tools and sub-agents. */
+  getExtendedCard(agentId) {
+    return this.httpClient.get(this.path("agents", agentId, "a2a", "card", "extended"));
+  }
+};
+
+// src/resources/agents/index.ts
+var Agents = class extends BaseResource {
+  messages;
+  conversations;
+  tools;
+  access;
+  analytics;
+  evaluations;
+  a2a;
+  workspaceId;
+  constructor(httpClient, workspaceId) {
+    super(httpClient);
+    this.workspaceId = workspaceId;
+    this.messages = new Messages(httpClient, workspaceId);
+    this.conversations = new Conversations(httpClient, workspaceId);
+    this.tools = new Tools(httpClient, workspaceId);
+    this.access = new Access(httpClient, workspaceId);
+    this.analytics = new Analytics(httpClient, workspaceId);
+    this.evaluations = new Evaluations(httpClient, workspaceId);
+    this.a2a = new A2A(httpClient, workspaceId);
+  }
+  path(...segments) {
+    return this.buildPath(this.workspaceId, ...segments);
+  }
+  /** List all agents. */
+  list(params) {
+    return this._paginate(this.path("agents"), params);
+  }
+  /** Create a new agent. */
+  create(params) {
+    return this._post(this.path("agents"), params);
+  }
+  /** Get an agent by ID. */
+  get(agentId) {
+    return this.httpClient.get(this.path("agents", agentId));
+  }
+  /** Update an agent. */
+  update(agentId, params) {
+    return this._patch(this.path("agents", agentId), params);
+  }
+  /** Delete an agent. */
+  delete(agentId) {
+    return this._del(this.path("agents", agentId));
+  }
+  /** Publish an agent (promote draft to published). */
+  publish(agentId) {
+    return this._post(this.path("agents", agentId, "publish"));
+  }
+  /** Discard the current draft. */
+  discardDraft(agentId) {
+    return this._post(this.path("agents", agentId, "discard-draft"));
+  }
+  /** Update agent discovery settings. */
+  discovery(agentId, params) {
+    return this._patch(this.path("agents", agentId, "discovery"), params);
+  }
+  /** Export an agent configuration. */
+  export(agentId) {
+    return this.httpClient.get(this.path("agents", agentId, "export"));
+  }
+  /** Import an agent configuration. */
+  import(config) {
+    return this._post(this.path("agents", "import"), config);
+  }
+};
+
+// src/resources/tasks/index.ts
+var Tasks = class extends BaseResource {
+  workspaceId;
+  constructor(httpClient, workspaceId) {
+    super(httpClient);
+    this.workspaceId = workspaceId;
+  }
+  path(...segments) {
+    return this.buildPath(this.workspaceId, ...segments);
+  }
+  /** List tasks. */
+  list(params) {
+    return this._paginate(this.path("tasks"), params);
+  }
+  /** Get a task by ID. */
+  get(taskId) {
+    return this.httpClient.get(this.path("tasks", taskId));
+  }
+  /** Cancel a running task. */
+  cancel(taskId) {
+    return this._post(this.path("tasks", taskId, "cancel"));
+  }
+};
+
+// src/resources/artifacts/index.ts
+var Artifacts = class extends BaseResource {
+  workspaceId;
+  constructor(httpClient, workspaceId) {
+    super(httpClient);
+    this.workspaceId = workspaceId;
+  }
+  path(...segments) {
+    return this.buildPath(this.workspaceId, ...segments);
+  }
+  list(params) {
+    return this._paginate(this.path("artifacts"), params);
+  }
+  get(artifactId) {
+    return this.httpClient.get(this.path("artifacts", artifactId));
+  }
+  update(artifactId, params) {
+    return this._patch(this.path("artifacts", artifactId), params);
+  }
+  delete(artifactId) {
+    return this._del(this.path("artifacts", artifactId));
+  }
+  share(artifactId, params) {
+    return this._post(this.path("artifacts", artifactId, "share"), params);
+  }
+};
+
+// src/resources/shares/index.ts
+var Shares = class extends BaseResource {
+  workspaceId;
+  constructor(httpClient, workspaceId) {
+    super(httpClient);
+    this.workspaceId = workspaceId;
+  }
+  path(...segments) {
+    return this.buildPath(this.workspaceId, ...segments);
+  }
+  list(params) {
+    return this._paginate(this.path("shares"), params);
+  }
+  get(shareId) {
+    return this.httpClient.get(this.path("shares", shareId));
+  }
+};
+
+// src/resources/ratings/index.ts
+var Ratings = class extends BaseResource {
+  workspaceId;
+  constructor(httpClient, workspaceId) {
+    super(httpClient);
+    this.workspaceId = workspaceId;
+  }
+  path(...segments) {
+    return this.buildPath(this.workspaceId, ...segments);
+  }
+  /** Submit a rating for an agent response. */
+  create(params) {
+    return this._post(this.path("ratings"), params);
+  }
+};
+
+// src/resources/activity/index.ts
+var Activity = class extends BaseResource {
+  workspaceId;
+  constructor(httpClient, workspaceId) {
+    super(httpClient);
+    this.workspaceId = workspaceId;
+  }
+  path(...segments) {
+    return this.buildPath(this.workspaceId, ...segments);
+  }
+  /** List recent activity. */
+  list(params) {
+    return this._paginate(this.path("activity"), params);
+  }
+};
+
+// src/resources/profiles/index.ts
+var Profiles = class extends BaseResource {
+  workspaceId;
+  constructor(httpClient, workspaceId) {
+    super(httpClient);
+    this.workspaceId = workspaceId;
+  }
+  path(...segments) {
+    return this.buildPath(this.workspaceId, ...segments);
+  }
+  /** List user profiles. */
+  list(params) {
+    return this._paginate(this.path("profiles"), params);
+  }
+};
+
+// src/resources/orgs/index.ts
+var Orgs = class extends BaseResource {
+  workspaceId;
+  constructor(httpClient, workspaceId) {
+    super(httpClient);
+    this.workspaceId = workspaceId;
+  }
+  path(...segments) {
+    return this.buildPath(this.workspaceId, ...segments);
+  }
+  /** List agents available in the organization. */
+  listAgents(params) {
+    return this._paginate(this.path("orgs", "agents"), params);
+  }
+};
+
+// src/core/uploads.ts
+var import_promises = require("fs/promises");
+async function toFormData(fieldName, input, options = {}) {
+  const formData = new FormData();
+  const blob = await toBlob(input, options);
+  formData.append(fieldName, blob, options.filename ?? "file");
+  return formData;
+}
+async function toBlob(input, options) {
+  const contentType = options.contentType ?? "application/octet-stream";
+  if (input instanceof Blob) {
+    return input;
+  }
+  if (typeof input === "string") {
+    const data = await (0, import_promises.readFile)(input);
+    return new Blob([data], { type: contentType });
+  }
+  if (input instanceof Buffer || input instanceof ArrayBuffer || input instanceof Uint8Array) {
+    return new Blob([input], { type: contentType });
+  }
+  if (input instanceof ReadableStream) {
+    const chunks = [];
+    const reader = input.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+    }
+    return new Blob(chunks, { type: contentType });
+  }
+  throw new TypeError(`Unsupported file input type: ${typeof input}`);
+}
+function mimeFromFilename(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  const mimeTypes = {
+    pdf: "application/pdf",
+    json: "application/json",
+    csv: "text/csv",
+    txt: "text/plain",
+    md: "text/markdown",
+    html: "text/html",
+    xml: "application/xml",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    svg: "image/svg+xml",
+    webp: "image/webp",
+    mp3: "audio/mpeg",
+    mp4: "video/mp4",
+    zip: "application/zip",
+    doc: "application/msword",
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    xls: "application/vnd.ms-excel",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+  };
+  return mimeTypes[ext ?? ""] ?? "application/octet-stream";
+}
+
+// src/resources/storage/files.ts
+var Files = class extends BaseResource {
+  workspaceId;
+  constructor(httpClient, workspaceId) {
+    super(httpClient);
+    this.workspaceId = workspaceId;
+  }
+  path(...segments) {
+    return this.buildPath(this.workspaceId, ...segments);
+  }
+  /** List files. */
+  list(params) {
+    return this._paginate(this.path("files"), params);
+  }
+  /** Upload a file. */
+  async upload(file, params) {
+    const filename = params?.filename ?? params?.name ?? "file";
+    const contentType = params?.contentType ?? mimeFromFilename(filename);
+    const formData = await toFormData("file", file, { filename, contentType });
+    if (params?.name) {
+      formData.append("name", params.name);
+    }
+    if (params?.metadata) {
+      formData.append("metadata", JSON.stringify(params.metadata));
+    }
+    return this.httpClient.post(this.path("files"), formData);
+  }
+  /** Get file metadata. */
+  get(fileId) {
+    return this.httpClient.get(this.path("files", fileId));
+  }
+  /** Delete a file. */
+  delete(fileId) {
+    return this._del(this.path("files", fileId));
+  }
+  /** Download a file. Returns the raw Response for streaming. */
+  async download(fileId) {
+    return this.httpClient.requestRaw({
+      method: "GET",
+      path: this.path("files", fileId, "download")
+    });
+  }
+};
+
+// src/resources/storage/vector-stores/files.ts
+var VSFiles = class extends BaseResource {
+  workspaceId;
+  constructor(httpClient, workspaceId) {
+    super(httpClient);
+    this.workspaceId = workspaceId;
+  }
+  path(...segments) {
+    return this.buildPath(this.workspaceId, ...segments);
+  }
+  /** List files in a vector store. */
+  list(vectorStoreId, params) {
+    return this._paginate(
+      this.path("vector-stores", vectorStoreId, "files"),
+      params
+    );
+  }
+  /** Add a file to a vector store. */
+  add(vectorStoreId, params) {
+    return this._post(
+      this.path("vector-stores", vectorStoreId, "files"),
+      params
+    );
+  }
+  /** Update a file in a vector store. */
+  update(vectorStoreId, fileId, params) {
+    return this._patch(
+      this.path("vector-stores", vectorStoreId, "files", fileId),
+      params
+    );
+  }
+  /** Remove a file from a vector store. */
+  delete(vectorStoreId, fileId) {
+    return this._del(
+      this.path("vector-stores", vectorStoreId, "files", fileId)
+    );
+  }
+  /** Get chunks for a file in a vector store. */
+  chunks(vectorStoreId, fileId) {
+    return this.httpClient.get(
+      this.path("vector-stores", vectorStoreId, "files", fileId, "chunks")
+    );
+  }
+  /** Reindex a specific file in a vector store. */
+  reindex(vectorStoreId, fileId) {
+    return this._post(
+      this.path("vector-stores", vectorStoreId, "files", fileId, "reindex")
+    );
+  }
+};
+
+// src/resources/storage/vector-stores/access.ts
+var VSAccess = class extends BaseResource {
+  workspaceId;
+  constructor(httpClient, workspaceId) {
+    super(httpClient);
+    this.workspaceId = workspaceId;
+  }
+  path(...segments) {
+    return this.buildPath(this.workspaceId, ...segments);
+  }
+  /** List access entries for a vector store. */
+  list(vectorStoreId) {
+    return this._paginate(
+      this.path("vector-stores", vectorStoreId, "access")
+    );
+  }
+  /** Grant access to a vector store. */
+  grant(vectorStoreId, params) {
+    return this._post(
+      this.path("vector-stores", vectorStoreId, "access"),
+      params
+    );
+  }
+  /** Update access for a vector store. */
+  update(vectorStoreId, accessId, params) {
+    return this._patch(
+      this.path("vector-stores", vectorStoreId, "access", accessId),
+      params
+    );
+  }
+  /** Revoke access to a vector store. */
+  revoke(vectorStoreId, accessId) {
+    return this._del(
+      this.path("vector-stores", vectorStoreId, "access", accessId)
+    );
+  }
+};
+
+// src/resources/storage/vector-stores/index.ts
+var VectorStores = class extends BaseResource {
+  files;
+  access;
+  workspaceId;
+  constructor(httpClient, workspaceId) {
+    super(httpClient);
+    this.workspaceId = workspaceId;
+    this.files = new VSFiles(httpClient, workspaceId);
+    this.access = new VSAccess(httpClient, workspaceId);
+  }
+  path(...segments) {
+    return this.buildPath(this.workspaceId, ...segments);
+  }
+  /** List vector stores. */
+  list(params) {
+    return this._paginate(this.path("vector-stores"), params);
+  }
+  /** Create a new vector store. */
+  create(params) {
+    return this._post(this.path("vector-stores"), params);
+  }
+  /** Get a vector store by ID. */
+  get(vectorStoreId) {
+    return this.httpClient.get(this.path("vector-stores", vectorStoreId));
+  }
+  /** Update a vector store. */
+  update(vectorStoreId, params) {
+    return this._patch(this.path("vector-stores", vectorStoreId), params);
+  }
+  /** Delete a vector store. */
+  delete(vectorStoreId) {
+    return this._del(this.path("vector-stores", vectorStoreId));
+  }
+  /** Search a vector store. */
+  search(vectorStoreId, params) {
+    return this._post(
+      this.path("vector-stores", vectorStoreId, "search"),
+      params
+    );
+  }
+  /** Reindex a vector store. */
+  reindex(vectorStoreId) {
+    return this._post(this.path("vector-stores", vectorStoreId, "reindex"));
+  }
+  /** Get crawl status for a vector store. */
+  crawlStatus(vectorStoreId) {
+    return this.httpClient.get(
+      this.path("vector-stores", vectorStoreId, "crawl-status")
+    );
+  }
+  /** Trigger a recrawl for a vector store. */
+  recrawl(vectorStoreId) {
+    return this._post(this.path("vector-stores", vectorStoreId, "recrawl"));
+  }
+};
+
+// src/resources/storage/skills.ts
+var Skills = class extends BaseResource {
+  workspaceId;
+  constructor(httpClient, workspaceId) {
+    super(httpClient);
+    this.workspaceId = workspaceId;
+  }
+  path(...segments) {
+    return this.buildPath(this.workspaceId, ...segments);
+  }
+  list(params) {
+    return this._paginate(this.path("skills"), params);
+  }
+  create(params) {
+    return this._post(this.path("skills"), params);
+  }
+  get(skillId) {
+    return this.httpClient.get(this.path("skills", skillId));
+  }
+  update(skillId, params) {
+    return this._patch(this.path("skills", skillId), params);
+  }
+  delete(skillId) {
+    return this._del(this.path("skills", skillId));
+  }
+};
+
+// src/resources/storage/stats.ts
+var Stats = class extends BaseResource {
+  workspaceId;
+  constructor(httpClient, workspaceId) {
+    super(httpClient);
+    this.workspaceId = workspaceId;
+  }
+  path(...segments) {
+    return this.buildPath(this.workspaceId, ...segments);
+  }
+  /** Get storage statistics. */
+  get(params) {
+    return this.httpClient.get(
+      this.path("stats"),
+      params
+    );
+  }
+};
+
+// src/resources/storage/index.ts
+var Storage = class {
+  files;
+  vectorStores;
+  skills;
+  stats;
+  constructor(httpClient, workspaceId) {
+    this.files = new Files(httpClient, workspaceId);
+    this.vectorStores = new VectorStores(httpClient, workspaceId);
+    this.skills = new Skills(httpClient, workspaceId);
+    this.stats = new Stats(httpClient, workspaceId);
+  }
+};
+
+// src/client.ts
+var ENVIRONMENTS = {
+  sandbox: "https://api.sandbox.prisme.ai/v2",
+  production: "https://api.eda.prisme.ai/v2",
+  prod: "https://api.eda.prisme.ai/v2"
+};
+var PrismeAI = class {
+  /** Agent Factory resources. */
+  agents;
+  tasks;
+  artifacts;
+  shares;
+  ratings;
+  activity;
+  profiles;
+  orgs;
+  /** Storage resources (files, vector stores, skills, stats). */
+  storage;
+  agentFactoryClient;
+  storageClient;
+  constructor(options) {
+    const baseURL = resolveBaseURL(options);
+    const headers = buildAuthHeaders(options);
+    this.agentFactoryClient = new HttpClient({
+      baseURL,
+      headers,
+      timeout: options.timeout,
+      maxRetries: options.maxRetries
+    });
+    this.agents = new Agents(this.agentFactoryClient, options.agentFactoryWorkspaceId);
+    this.tasks = new Tasks(this.agentFactoryClient, options.agentFactoryWorkspaceId);
+    this.artifacts = new Artifacts(this.agentFactoryClient, options.agentFactoryWorkspaceId);
+    this.shares = new Shares(this.agentFactoryClient, options.agentFactoryWorkspaceId);
+    this.ratings = new Ratings(this.agentFactoryClient, options.agentFactoryWorkspaceId);
+    this.activity = new Activity(this.agentFactoryClient, options.agentFactoryWorkspaceId);
+    this.profiles = new Profiles(this.agentFactoryClient, options.agentFactoryWorkspaceId);
+    this.orgs = new Orgs(this.agentFactoryClient, options.agentFactoryWorkspaceId);
+    if (options.storageWorkspaceId) {
+      this.storageClient = new HttpClient({
+        baseURL,
+        headers,
+        timeout: options.timeout,
+        maxRetries: options.maxRetries
+      });
+      this.storage = new Storage(this.storageClient, options.storageWorkspaceId);
+    } else {
+      this.storage = new Storage(this.agentFactoryClient, options.agentFactoryWorkspaceId);
+    }
+  }
+};
+function resolveBaseURL(options) {
+  if (options.baseURL) return options.baseURL;
+  if (options.environment) {
+    const env = ENVIRONMENTS[options.environment];
+    if (env) return env;
+    if (options.environment.startsWith("http")) return options.environment;
+    throw new Error(
+      `Unknown environment: "${options.environment}". Use "sandbox", "production", or provide a baseURL.`
+    );
+  }
+  return ENVIRONMENTS.production;
+}
+function buildAuthHeaders(options) {
+  const headers = {};
+  if (options.apiKey) {
+    headers["x-prismeai-api-key"] = options.apiKey;
+  }
+  if (options.bearerToken) {
+    headers["authorization"] = `Bearer ${options.bearerToken}`;
+  }
+  if (!options.apiKey && !options.bearerToken) {
+    const envApiKey = process.env.PRISMEAI_API_KEY;
+    const envBearerToken = process.env.PRISMEAI_BEARER_TOKEN;
+    if (envApiKey) {
+      headers["x-prismeai-api-key"] = envApiKey;
+    } else if (envBearerToken) {
+      headers["authorization"] = `Bearer ${envBearerToken}`;
+    }
+  }
+  return headers;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthenticationError,
+  ConflictError,
+  ConnectionError,
+  InternalServerError,
+  NotFoundError,
+  PageIterator,
+  PermissionDeniedError,
+  PrismeAI,
+  PrismeAIError,
+  RateLimitError,
+  SSEStream,
+  TimeoutError,
+  ValidationError
+});
+//# sourceMappingURL=index.js.map