@agentuity/core 0.0.29 → 0.0.30

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agentuity/core",
-	"version": "0.0.29",
+	"version": "0.0.30",
 	"type": "module",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
@@ -17,7 +17,7 @@
 	},
 	"scripts": {
 		"clean": "rm -rf dist",
-		"build": "bun build --target bun src/index.ts --outdir ./dist && bunx tsc --build --emitDeclarationOnly --force",
+		"build": "bunx tsc --build --emitDeclarationOnly --force",
 		"typecheck": "bunx tsc --noEmit",
 		"prepublishOnly": "bun run clean && bun run build"
 	},

package/dist/index.js

@@ -1,1014 +0,0 @@
-// @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __require = import.meta.require;
-
-// src/json.ts
-function safeStringify(obj) {
-  const visited = new WeakSet;
-  function replacer(_key, value) {
-    if (typeof value === "bigint") {
-      return value.toString();
-    }
-    if (typeof value === "object" && value !== null) {
-      if (visited.has(value)) {
-        return "[Circular]";
-      }
-      visited.add(value);
-      return value;
-    }
-    return value;
-  }
-  return JSON.stringify(obj, replacer);
-}
-// src/services/exception.ts
-class ServiceException extends Error {
-  statusCode;
-  constructor(message, statusCode) {
-    super(message);
-    this.statusCode = statusCode;
-  }
-}
-// src/services/_util.ts
-var buildUrl = (base, path, subpath, query) => {
-  path = path.startsWith("/") ? path : `/${path}`;
-  let url = base.replace(/\/$/, "") + path;
-  if (subpath) {
-    subpath = subpath.startsWith("/") ? subpath : `/${subpath}`;
-    url += subpath;
-  }
-  if (query) {
-    url += `?${query.toString()}`;
-  }
-  return url;
-};
-async function toServiceException(response) {
-  switch (response.status) {
-    case 401:
-    case 403:
-      return new ServiceException("Unauthorized", response.status);
-    case 404:
-      return new ServiceException("Not Found", response.status);
-    default:
-  }
-  const ct = response.headers.get("content-type");
-  if (ct?.includes("json")) {
-    try {
-      const payload = await response.json();
-      if (payload.error) {
-        return new ServiceException(payload.error, response.status);
-      }
-      if (payload.message) {
-        return new ServiceException(payload.message, response.status);
-      }
-      return new ServiceException(JSON.stringify(payload), response.status);
-    } catch {}
-  }
-  try {
-    const body = await response.text();
-    return new ServiceException(body, response.status);
-  } catch {}
-  return new ServiceException(response.statusText, response.status);
-}
-var binaryContentType = "application/octet-stream";
-var textContentType = "text/plain";
-var jsonContentType = "application/json";
-async function toPayload(data) {
-  if (data === undefined || data === null) {
-    return ["", textContentType];
-  }
-  switch (typeof data) {
-    case "string":
-      if (data.charAt(0) === "{" && data.charAt(data.length - 1) === "}" || data.charAt(0) === "[" && data.charAt(data.length - 1) === "]") {
-        try {
-          JSON.parse(data);
-          return [data, jsonContentType];
-        } catch {}
-      }
-      return [data, textContentType];
-    case "boolean":
-      return [String(data), textContentType];
-    case "number":
-      return [String(data), textContentType];
-    case "object": {
-      if (data instanceof ArrayBuffer) {
-        return [data, binaryContentType];
-      }
-      if (data instanceof Buffer) {
-        return [data, binaryContentType];
-      }
-      if (data instanceof ReadableStream) {
-        return [data, binaryContentType];
-      }
-      if (data instanceof Promise) {
-        return toPayload(await data);
-      }
-      if (data instanceof Function) {
-        return toPayload(data());
-      }
-      return [safeStringify(data), jsonContentType];
-    }
-  }
-  return ["", textContentType];
-}
-async function fromResponse(response) {
-  const contentType = response.headers.get("content-type");
-  if (!contentType || contentType?.includes("/json")) {
-    return await response.json();
-  }
-  if (contentType?.includes("text/")) {
-    return await response.text();
-  }
-  if (contentType?.includes(binaryContentType)) {
-    return await response.arrayBuffer();
-  }
-  throw new ServiceException(`Unsupported content-type: ${contentType}`, response.status);
-}
-
-// src/services/keyvalue.ts
-class KeyValueStorageService {
-  #adapter;
-  #baseUrl;
-  constructor(baseUrl, adapter) {
-    this.#adapter = adapter;
-    this.#baseUrl = baseUrl;
-  }
-  async get(name, key) {
-    const url = buildUrl(this.#baseUrl, `/kv/2025-03-17/${encodeURIComponent(name)}/${encodeURIComponent(key)}`);
-    const signal = AbortSignal.timeout(1e4);
-    const res = await this.#adapter.invoke(url, {
-      method: "GET",
-      signal,
-      telemetry: {
-        name: "agentuity.keyvalue.get",
-        attributes: {
-          name,
-          key
-        }
-      }
-    });
-    if (res.ok) {
-      return {
-        data: res.data,
-        contentType: res.response.headers.get("content-type") ?? "application/octet-stream",
-        exists: true
-      };
-    }
-    if (res.response.status === 404) {
-      return { exists: false };
-    }
-    throw await toServiceException(res.response);
-  }
-  async set(name, key, value, params) {
-    let ttlstr = "";
-    if (params?.ttl) {
-      if (params.ttl < 60) {
-        throw new Error(`ttl for keyvalue set must be at least 60 seconds, got ${params.ttl}`);
-      }
-      ttlstr = `/${params.ttl}`;
-    }
-    const url = buildUrl(this.#baseUrl, `/kv/2025-03-17/${encodeURIComponent(name)}/${encodeURIComponent(key)}${ttlstr}`);
-    const [body, contentType] = await toPayload(value);
-    const signal = AbortSignal.timeout(30000);
-    const res = await this.#adapter.invoke(url, {
-      method: "PUT",
-      signal,
-      body,
-      contentType: params?.contentType || contentType,
-      telemetry: {
-        name: "agentuity.keyvalue.set",
-        attributes: {
-          name,
-          key,
-          ttl: ttlstr
-        }
-      }
-    });
-    if (res.ok) {
-      return;
-    }
-    throw await toServiceException(res.response);
-  }
-  async delete(name, key) {
-    const url = buildUrl(this.#baseUrl, `/kv/2025-03-17/${encodeURIComponent(name)}/${encodeURIComponent(key)}`);
-    const signal = AbortSignal.timeout(30000);
-    const res = await this.#adapter.invoke(url, {
-      method: "DELETE",
-      signal,
-      telemetry: {
-        name: "agentuity.keyvalue.delete",
-        attributes: {
-          name,
-          key
-        }
-      }
-    });
-    if (res.ok) {
-      return;
-    }
-    throw await toServiceException(res.response);
-  }
-}
-// src/services/objectstore.ts
-class ObjectStorageService {
-  #adapter;
-  #baseUrl;
-  constructor(baseUrl, adapter) {
-    this.#baseUrl = baseUrl;
-    this.#adapter = adapter;
-  }
-  async get(bucket, key) {
-    if (!bucket?.trim()) {
-      throw new Error("bucket is required and cannot be empty");
-    }
-    if (!key?.trim()) {
-      throw new Error("key is required and cannot be empty");
-    }
-    const url = buildUrl(this.#baseUrl, `/object/2025-03-17/${encodeURIComponent(bucket)}/${encodeURIComponent(key)}`);
-    const signal = AbortSignal.timeout(1e4);
-    const options = {
-      method: "GET",
-      signal,
-      telemetry: {
-        name: "agentuity.objectstore.get",
-        attributes: {
-          "objectstore.bucket": bucket,
-          "objectstore.key": key
-        }
-      }
-    };
-    try {
-      const result = await this.#adapter.invoke(url, options);
-      if (result.response.status === 404) {
-        return { exists: false };
-      }
-      if (!result.ok) {
-        throw new Error(`Failed to get object: ${result.response.statusText} (${result.response.status})`);
-      }
-      const data = result.data;
-      if (!(data instanceof ArrayBuffer)) {
-        throw new Error("Expected ArrayBuffer response from object store");
-      }
-      const contentType = result.response.headers.get("content-type") || "application/octet-stream";
-      return {
-        exists: true,
-        data: new Uint8Array(data),
-        contentType
-      };
-    } catch (err) {
-      if (err instanceof Response) {
-        throw await toServiceException(err);
-      }
-      throw err;
-    }
-  }
-  async put(bucket, key, data, params) {
-    if (!bucket?.trim()) {
-      throw new Error("bucket is required and cannot be empty");
-    }
-    if (!key?.trim()) {
-      throw new Error("key is required and cannot be empty");
-    }
-    if (!data) {
-      throw new Error("data is required");
-    }
-    const url = buildUrl(this.#baseUrl, `/object/2025-03-17/${encodeURIComponent(bucket)}/${encodeURIComponent(key)}`);
-    const headers = {
-      "Content-Type": params?.contentType || "application/octet-stream"
-    };
-    if (params?.contentEncoding) {
-      headers["Content-Encoding"] = params.contentEncoding;
-    }
-    if (params?.cacheControl) {
-      headers["Cache-Control"] = params.cacheControl;
-    }
-    if (params?.contentDisposition) {
-      headers["Content-Disposition"] = params.contentDisposition;
-    }
-    if (params?.contentLanguage) {
-      headers["Content-Language"] = params.contentLanguage;
-    }
-    if (params?.metadata) {
-      for (const [metaKey, metaValue] of Object.entries(params.metadata)) {
-        headers[`x-metadata-${metaKey}`] = metaValue;
-      }
-    }
-    let body;
-    if (data instanceof ArrayBuffer) {
-      body = data;
-    } else if (data instanceof Uint8Array) {
-      if (data.byteOffset !== 0 || data.byteLength !== data.buffer.byteLength) {
-        body = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
-      } else {
-        body = data.buffer;
-      }
-    } else {
-      body = data;
-    }
-    const signal = AbortSignal.timeout(30000);
-    const options = {
-      method: "PUT",
-      headers,
-      body,
-      signal,
-      telemetry: {
-        name: "agentuity.objectstore.put",
-        attributes: {
-          "objectstore.bucket": bucket,
-          "objectstore.key": key,
-          "objectstore.contentType": params?.contentType || "application/octet-stream"
-        }
-      }
-    };
-    try {
-      const result = await this.#adapter.invoke(url, options);
-      if (!result.ok || result.response.status !== 200 && result.response.status !== 201) {
-        throw new Error(`Failed to put object: ${result.response.statusText} (${result.response.status})`);
-      }
-    } catch (err) {
-      if (err instanceof Response) {
-        throw await toServiceException(err);
-      }
-      throw err;
-    }
-  }
-  async delete(bucket, key) {
-    if (!bucket?.trim()) {
-      throw new Error("bucket is required and cannot be empty");
-    }
-    if (!key?.trim()) {
-      throw new Error("key is required and cannot be empty");
-    }
-    const url = buildUrl(this.#baseUrl, `/object/2025-03-17/${encodeURIComponent(bucket)}/${encodeURIComponent(key)}`);
-    const signal = AbortSignal.timeout(1e4);
-    const options = {
-      method: "DELETE",
-      signal,
-      telemetry: {
-        name: "agentuity.objectstore.delete",
-        attributes: {
-          "objectstore.bucket": bucket,
-          "objectstore.key": key
-        }
-      }
-    };
-    try {
-      const result = await this.#adapter.invoke(url, options);
-      if (result.response.status === 404) {
-        return false;
-      }
-      if (result.response.status === 200) {
-        return true;
-      }
-      throw new Error(`Failed to delete object: ${result.response.statusText} (${result.response.status})`);
-    } catch (err) {
-      if (err instanceof Response) {
-        throw await toServiceException(err);
-      }
-      throw err;
-    }
-  }
-  async createPublicURL(bucket, key, params) {
-    if (!bucket?.trim()) {
-      throw new Error("bucket is required and cannot be empty");
-    }
-    if (!key?.trim()) {
-      throw new Error("key is required and cannot be empty");
-    }
-    const url = buildUrl(this.#baseUrl, `/object/2025-03-17/presigned/${encodeURIComponent(bucket)}/${encodeURIComponent(key)}`);
-    const requestBody = {};
-    if (params?.expiresDuration) {
-      requestBody.expires = params.expiresDuration;
-    }
-    const signal = AbortSignal.timeout(1e4);
-    const options = {
-      method: "POST",
-      contentType: "application/json",
-      body: JSON.stringify(requestBody),
-      signal,
-      telemetry: {
-        name: "agentuity.objectstore.createPublicURL",
-        attributes: {
-          "objectstore.bucket": bucket,
-          "objectstore.key": key,
-          "objectstore.expiresDuration": params?.expiresDuration?.toString() || ""
-        }
-      }
-    };
-    try {
-      const result = await this.#adapter.invoke(url, options);
-      if (!result.ok) {
-        throw new Error(`Failed to create public URL: ${result.response.statusText} (${result.response.status})`);
-      }
-      const data = result.data;
-      if (!data.success) {
-        throw new Error(data.message || "Failed to create public URL");
-      }
-      return data.url;
-    } catch (err) {
-      if (err instanceof Error && err.message.includes("Object not found")) {
-        throw err;
-      }
-      if (err instanceof Response) {
-        throw await toServiceException(err);
-      }
-      throw err;
-    }
-  }
-}
-// src/services/stream.ts
-var encoder = new TextEncoder;
-
-class StreamImpl extends WritableStream {
-  id;
-  url;
-  activeWriter = null;
-  _compressed;
-  _adapter;
-  _sink;
-  constructor(id, url, compressed, underlyingSink, adapter) {
-    super(underlyingSink);
-    this.id = id;
-    this.url = url;
-    this._compressed = compressed;
-    this._adapter = adapter;
-    this._sink = underlyingSink;
-  }
-  get bytesWritten() {
-    return this._sink.total;
-  }
-  get compressed() {
-    return this._compressed;
-  }
-  async write(chunk) {
-    let binaryChunk;
-    if (chunk instanceof Uint8Array) {
-      binaryChunk = chunk;
-    } else if (typeof chunk === "string") {
-      binaryChunk = encoder.encode(chunk);
-    } else if (chunk instanceof ArrayBuffer) {
-      binaryChunk = new Uint8Array(chunk);
-    } else if (typeof chunk === "object" && chunk !== null) {
-      binaryChunk = encoder.encode(safeStringify(chunk));
-    } else {
-      binaryChunk = encoder.encode(String(chunk));
-    }
-    if (!this.activeWriter) {
-      this.activeWriter = this.getWriter();
-    }
-    await this.activeWriter.write(binaryChunk);
-  }
-  async close() {
-    try {
-      if (this.activeWriter) {
-        const writer2 = this.activeWriter;
-        this.activeWriter = null;
-        await writer2.close();
-        return;
-      }
-      const writer = this.getWriter();
-      await writer.close();
-    } catch (error) {
-      if (error instanceof TypeError && (error.message.includes("closed") || error.message.includes("errored") || error.message.includes("Cannot close"))) {
-        return Promise.resolve();
-      }
-      if (error instanceof TypeError && error.message.includes("locked")) {
-        return Promise.resolve();
-      }
-      throw error;
-    }
-  }
-  getReader() {
-    const url = this.url;
-    const adapter = this._adapter;
-    let ac = null;
-    return new ReadableStream({
-      async start(controller) {
-        try {
-          ac = new AbortController;
-          const res = await adapter.invoke(url, {
-            method: "GET",
-            signal: ac.signal,
-            binary: true
-          });
-          const response = res.response;
-          if (!res.ok) {
-            controller.error(new Error(`Failed to read stream: ${response.status} ${response.statusText}`));
-            return;
-          }
-          if (!response.body) {
-            controller.error(new Error("Response body is null"));
-            return;
-          }
-          const reader = response.body.getReader();
-          try {
-            while (true) {
-              const { done, value } = await reader.read();
-              if (done)
-                break;
-              if (value)
-                controller.enqueue(value);
-            }
-            controller.close();
-          } catch (error) {
-            controller.error(error);
-          }
-        } catch (error) {
-          controller.error(error);
-        }
-      },
-      cancel(reason) {
-        if (ac) {
-          ac.abort(reason);
-          ac = null;
-        }
-      }
-    });
-  }
-}
-
-class UnderlyingSink {
-  adapter;
-  abortController = null;
-  writer = null;
-  putRequestPromise = null;
-  total = 0;
-  closed = false;
-  url;
-  props;
-  constructor(url, adapter, props) {
-    this.url = url;
-    this.adapter = adapter;
-    this.props = props;
-  }
-  async start() {
-    this.abortController = new AbortController;
-    let { readable, writable } = new TransformStream;
-    if (this.props?.compress) {
-      const { Readable, Writable } = await import("stream");
-      const { readable: compressedReadable, writable: compressedWritable } = new TransformStream;
-      const { createGzip } = await import("zlib");
-      const gzipStream = createGzip();
-      const nodeWritable = Writable.toWeb(gzipStream);
-      const gzipReader = Readable.toWeb(gzipStream);
-      gzipReader.pipeTo(compressedWritable).catch((error) => {
-        this.abortController?.abort(error);
-        this.writer?.abort(error).catch(() => {});
-      });
-      readable.pipeTo(nodeWritable).catch((error) => {
-        this.abortController?.abort(error);
-        this.writer?.abort(error).catch(() => {});
-      });
-      readable = compressedReadable;
-    }
-    this.writer = writable.getWriter();
-    const headers = {
-      "Content-Type": this.props?.contentType || "application/octet-stream"
-    };
-    if (this.props?.compress) {
-      headers["Content-Encoding"] = "gzip";
-    }
-    this.putRequestPromise = this.adapter.invoke(this.url, {
-      method: "PUT",
-      headers,
-      body: readable,
-      signal: this.abortController.signal,
-      duplex: "half"
-    });
-  }
-  async write(chunk) {
-    if (!this.writer) {
-      throw new Error("Stream writer not initialized");
-    }
-    let binaryChunk;
-    if (chunk instanceof Uint8Array) {
-      binaryChunk = chunk;
-    } else if (typeof chunk === "string") {
-      binaryChunk = new TextEncoder().encode(chunk);
-    } else if (chunk instanceof ArrayBuffer) {
-      binaryChunk = new Uint8Array(chunk);
-    } else if (typeof chunk === "object" && chunk !== null) {
-      binaryChunk = new TextEncoder().encode(safeStringify(chunk));
-    } else {
-      binaryChunk = new TextEncoder().encode(String(chunk));
-    }
-    await this.writer.write(binaryChunk);
-    this.total += binaryChunk.length;
-  }
-  async close() {
-    if (this.closed) {
-      return;
-    }
-    this.closed = true;
-    if (this.writer) {
-      await this.writer.close();
-      this.writer = null;
-    }
-    if (this.putRequestPromise) {
-      try {
-        const res = await this.putRequestPromise;
-        if (!res.ok) {
-          throw new Error(`PUT request failed: ${res.response.status} ${res.response.statusText}`);
-        }
-      } catch (error) {
-        if (error instanceof Error && error.name !== "AbortError") {
-          throw error;
-        }
-      }
-      this.putRequestPromise = null;
-    }
-    this.abortController = null;
-  }
-  async abort(reason) {
-    if (this.writer) {
-      await this.writer.abort(reason);
-      this.writer = null;
-    }
-    if (this.abortController) {
-      this.abortController.abort(reason);
-      this.abortController = null;
-    }
-    this.putRequestPromise = null;
-  }
-}
-
-class StreamStorageService {
-  #adapter;
-  #baseUrl;
-  constructor(baseUrl, adapter) {
-    this.#adapter = adapter;
-    this.#baseUrl = baseUrl;
-  }
-  async create(name, props) {
-    if (!name || name.length < 1 || name.length > 254) {
-      throw new Error("Stream name must be between 1 and 254 characters");
-    }
-    const url = this.#baseUrl;
-    const signal = AbortSignal.timeout(1e4);
-    const attributes = {
-      name
-    };
-    if (!props?.contentType) {
-      props = props ?? {};
-      props.contentType = "application/octet-stream";
-    }
-    if (props?.metadata) {
-      attributes["metadata"] = JSON.stringify(props.metadata);
-    }
-    if (props?.contentType) {
-      attributes["stream.content_type"] = props.contentType;
-    }
-    const body = JSON.stringify({
-      name,
-      ...props?.metadata && { metadata: props.metadata },
-      ...props?.contentType && { contentType: props.contentType }
-    });
-    const res = await this.#adapter.invoke(url, {
-      method: "POST",
-      body,
-      contentType: "application/json",
-      signal,
-      telemetry: {
-        name: "agentuity.stream.create",
-        attributes
-      }
-    });
-    if (res.ok) {
-      const streamUrl = buildUrl(this.#baseUrl, res.data.id);
-      const underlyingSink = new UnderlyingSink(streamUrl, this.#adapter, props);
-      const stream = new StreamImpl(res.data.id, streamUrl, props?.compress ?? false, underlyingSink, this.#adapter);
-      return stream;
-    }
-    throw await toServiceException(res.response);
-  }
-  async list(params) {
-    const attributes = {};
-    if (params?.limit !== undefined) {
-      if (params.limit <= 0 || params.limit > 1000) {
-        throw new Error("limit must be greater than 0 and less than or equal to 1000");
-      }
-      attributes["limit"] = String(params.limit);
-    }
-    if (params?.offset !== undefined) {
-      attributes["offset"] = String(params.offset);
-    }
-    if (params?.name) {
-      attributes["name"] = params.name;
-    }
-    if (params?.metadata) {
-      attributes["metadata"] = JSON.stringify(params.metadata);
-    }
-    const requestBody = {};
-    if (params?.name) {
-      requestBody.name = params.name;
-    }
-    if (params?.metadata) {
-      requestBody.metadata = params.metadata;
-    }
-    if (params?.limit) {
-      requestBody.limit = params.limit;
-    }
-    if (params?.offset) {
-      requestBody.offset = params.offset;
-    }
-    const signal = AbortSignal.timeout(30000);
-    const url = buildUrl(this.#baseUrl, "list");
-    const res = await this.#adapter.invoke(url, {
-      method: "POST",
-      signal,
-      body: JSON.stringify(requestBody),
-      contentType: "application/json",
-      telemetry: {
-        name: "agentuity.stream.list",
-        attributes
-      }
-    });
-    if (res.ok) {
-      return res.data;
-    }
-    throw await toServiceException(res.response);
-  }
-  async delete(id) {
-    if (!id || typeof id !== "string" || id.trim().length === 0) {
-      throw new Error("Stream id is required and must be a non-empty string");
-    }
-    const signal = AbortSignal.timeout(30000);
-    const url = buildUrl(this.#baseUrl, id);
-    const res = await this.#adapter.invoke(url, {
-      method: "DELETE",
-      signal,
-      telemetry: {
-        name: "agentuity.stream.delete",
-        attributes: {
-          "stream.id": id
-        }
-      }
-    });
-    if (res.ok) {
-      return;
-    }
-    throw await toServiceException(res.response);
-  }
-}
-// src/services/vector.ts
-class VectorStorageService {
-  #adapter;
-  #baseUrl;
-  constructor(baseUrl, adapter) {
-    this.#adapter = adapter;
-    this.#baseUrl = baseUrl;
-  }
-  async upsert(name, ...documents) {
-    if (!name || typeof name !== "string" || name.trim().length === 0) {
-      throw new Error("Vector storage name is required and must be a non-empty string");
-    }
-    if (!documents || documents.length === 0) {
-      throw new Error("At least one document is required for upsert");
-    }
-    for (const doc of documents) {
-      if (!doc.key || typeof doc.key !== "string" || doc.key.trim().length === 0) {
-        throw new Error("Each document must have a non-empty key");
-      }
-      if (!("embeddings" in doc) && !("document" in doc)) {
-        throw new Error("Each document must have either embeddings or document text");
-      }
-      if ("embeddings" in doc && doc.embeddings) {
-        if (!Array.isArray(doc.embeddings) || doc.embeddings.length === 0) {
-          throw new Error("Embeddings must be a non-empty array of numbers");
-        }
-      }
-      if ("document" in doc && doc.document) {
-        if (typeof doc.document !== "string" || doc.document.trim().length === 0) {
-          throw new Error("Document must be a non-empty string");
-        }
-      }
-    }
-    const url = buildUrl(this.#baseUrl, `/vector/2025-03-17/${encodeURIComponent(name)}`);
-    const signal = AbortSignal.timeout(30000);
-    const res = await this.#adapter.invoke(url, {
-      method: "PUT",
-      body: safeStringify(documents),
-      contentType: "application/json",
-      signal,
-      telemetry: {
-        name: "agentuity.vector.upsert",
-        attributes: {
-          name,
-          count: String(documents.length)
-        }
-      }
-    });
-    if (res.ok) {
-      if (res.data.success) {
-        return res.data.data.map((o, index) => ({
-          key: documents[index].key,
-          id: o.id
-        }));
-      }
-      if ("message" in res.data) {
-        throw new Error(res.data.message);
-      }
-    }
-    throw await toServiceException(res.response);
-  }
-  async get(name, key) {
-    if (!name || typeof name !== "string" || name.trim().length === 0) {
-      throw new Error("Vector storage name is required and must be a non-empty string");
-    }
-    if (!key || typeof key !== "string" || key.trim().length === 0) {
-      throw new Error("Key is required and must be a non-empty string");
-    }
-    const url = buildUrl(this.#baseUrl, `/vector/2025-03-17/${encodeURIComponent(name)}/${encodeURIComponent(key)}`);
-    const signal = AbortSignal.timeout(1e4);
-    const res = await this.#adapter.invoke(url, {
-      method: "GET",
-      signal,
-      telemetry: {
-        name: "agentuity.vector.get",
-        attributes: {
-          name,
-          key
-        }
-      }
-    });
-    if (res.response.status === 404) {
-      return { exists: false };
-    }
-    if (res.ok) {
-      if (res.data.success) {
-        return {
-          data: res.data.data,
-          exists: true
-        };
-      }
-      if ("message" in res.data) {
-        throw new Error(res.data.message);
-      }
-    }
-    throw await toServiceException(res.response);
-  }
-  async getMany(name, ...keys) {
-    if (!name || typeof name !== "string" || name.trim().length === 0) {
-      throw new Error("Vector storage name is required and must be a non-empty string");
-    }
-    if (keys.length === 0) {
-      return new Map;
-    }
-    for (const key of keys) {
-      if (!key || typeof key !== "string" || key.trim().length === 0) {
-        throw new Error("All keys must be non-empty strings");
-      }
-    }
-    const results = await Promise.all(keys.map((key) => this.get(name, key)));
-    const resultMap = new Map;
-    results.forEach((result, index) => {
-      if (result.exists) {
-        resultMap.set(keys[index], result.data);
-      }
-    });
-    return resultMap;
-  }
-  async search(name, params) {
-    if (!name || typeof name !== "string" || name.trim().length === 0) {
-      throw new Error("Vector storage name is required and must be a non-empty string");
-    }
-    if (!params.query || typeof params.query !== "string" || params.query.trim().length === 0) {
-      throw new Error("Query is required and must be a non-empty string");
-    }
-    if (params.limit !== undefined) {
-      if (typeof params.limit !== "number" || params.limit <= 0) {
-        throw new Error("Limit must be a positive number");
-      }
-    }
-    if (params.similarity !== undefined) {
-      if (typeof params.similarity !== "number" || params.similarity < 0 || params.similarity > 1) {
-        throw new Error("Similarity must be a number between 0.0 and 1.0");
-      }
-    }
-    if (params.metadata !== undefined) {
-      if (typeof params.metadata !== "object" || params.metadata === null) {
-        throw new Error("Metadata must be a valid object");
-      }
-    }
-    const url = buildUrl(this.#baseUrl, `/vector/2025-03-17/search/${encodeURIComponent(name)}`);
-    const signal = AbortSignal.timeout(30000);
-    const attributes = {
-      name,
-      query: params.query
-    };
-    if (params.limit !== undefined) {
-      attributes.limit = String(params.limit);
-    }
-    if (params.similarity !== undefined) {
-      attributes.similarity = String(params.similarity);
-    }
-    const res = await this.#adapter.invoke(url, {
-      method: "POST",
-      body: safeStringify(params),
-      contentType: "application/json",
-      signal,
-      telemetry: {
-        name: "agentuity.vector.search",
-        attributes
-      }
-    });
-    if (res.response.status === 404) {
-      return [];
-    }
-    if (res.ok) {
-      if (res.data.success) {
-        return res.data.data;
-      }
-      if ("message" in res.data) {
-        throw new Error(res.data.message);
-      }
-    }
-    throw await toServiceException(res.response);
-  }
-  async delete(name, ...keys) {
-    if (!name || typeof name !== "string" || name.trim().length === 0) {
-      throw new Error("Vector storage name is required and must be a non-empty string");
-    }
-    if (keys.length === 0) {
-      return 0;
-    }
-    for (const key of keys) {
-      if (!key || typeof key !== "string" || key.trim().length === 0) {
-        throw new Error("All keys must be non-empty strings");
-      }
-    }
-    const signal = AbortSignal.timeout(30000);
-    let url;
-    let body;
-    if (keys.length === 1) {
-      url = buildUrl(this.#baseUrl, `/vector/2025-03-17/${encodeURIComponent(name)}/${encodeURIComponent(keys[0])}`);
-    } else {
-      url = buildUrl(this.#baseUrl, `/vector/2025-03-17/${encodeURIComponent(name)}`);
-      body = safeStringify({ keys });
-    }
-    const res = await this.#adapter.invoke(url, {
-      method: "DELETE",
-      ...body && { body, contentType: "application/json" },
-      signal,
-      telemetry: {
-        name: "agentuity.vector.delete",
-        attributes: {
-          name,
-          count: String(keys.length)
-        }
-      }
-    });
-    if (res.ok) {
-      if (res.data.success) {
-        return res.data.data;
-      }
-      if ("message" in res.data) {
-        throw new Error(res.data.message);
-      }
-    }
-    throw await toServiceException(res.response);
-  }
-  async exists(name) {
-    if (!name || typeof name !== "string" || name.trim().length === 0) {
-      throw new Error("Vector storage name is required and must be a non-empty string");
-    }
-    try {
-      await this.search(name, { query: "_exists_check_", limit: 1 });
-      return true;
-    } catch (error) {
-      if (error instanceof Error) {
-        const statusMatch = error.message.match(/(\d{3})/);
-        if (statusMatch && statusMatch[1] === "404") {
-          return false;
-        }
-      }
-      throw error;
-    }
-  }
-}
-export {
-  toServiceException,
-  toPayload,
-  safeStringify,
-  fromResponse,
-  buildUrl,
-  VectorStorageService,
-  StreamStorageService,
-  ServiceException,
-  ObjectStorageService,
-  KeyValueStorageService
-};