@agentproto/registry 0.1.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jeremy André and agentproto contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,128 @@
+/**
+ * AIP-43 REGISTRY — public types.
+ *
+ * The registry is type-parametric over a doctype handle `H`. The
+ * package itself doesn't know what STORAGE / SANDBOX / OPERATOR
+ * handles look like — it just relies on a `keyBy(handle) => string`
+ * selector and treats `handle.capabilities` (if present) as opaque
+ * metadata for `lookup()` queries.
+ */
+interface RegistryOptions<H> {
+    /**
+     * Informational label used in error messages and (when discovery
+     * hooks are enabled) MCP tool names. Common values: `"storage"`,
+     * `"sandbox"`, `"operator"`. Doesn't affect lookup semantics.
+     */
+    family: string;
+    /**
+     * How to derive the registry key from a handle. Required when the
+     * handle type doesn't expose a recognisable id field; the default
+     * resolution (per AIP-43 § Identity) inspects `handle.id`,
+     * `handle.provider`, `handle.slug` in priority order.
+     */
+    keyBy?: (handle: H) => string;
+}
+interface Registry<H> {
+    /**
+     * Add a handle. Throws `RegistryDuplicateError` if the resolved key
+     * is already present — silent overwrite is unsafe (a second
+     * `defineStorage({ provider: "s3" })` shadowing the first is the
+     * exact bug class the registry exists to surface).
+     */
+    register(handle: H): void;
+    /** Returns true if the resolved key is registered. */
+    has(id: string): boolean;
+    /** Number of handles currently registered. */
+    count(): number;
+    /** Get the handle by id. Returns undefined if absent. */
+    get(id: string): H | undefined;
+    /** Every handle currently registered, insertion-ordered. */
+    list(): readonly H[];
+    /** Every `[id, handle]` pair, insertion-ordered. */
+    entries(): ReadonlyArray<readonly [string, H]>;
+    /**
+     * Every handle matching `predicate`. Predicate runs in registration
+     * order; ties are broken by insertion order.
+     */
+    lookup(predicate: (handle: H) => boolean): readonly H[];
+    /**
+     * Remove `id` from the registry. Returns true if a handle was
+     * removed. Use sparingly — registries are intended to be
+     * boot-time-stable.
+     */
+    unregister(id: string): boolean;
+    /**
+     * Replace an existing handle. Throws `RegistryNotFoundError` if no
+     * handle exists at `keyBy(handle)`. Use when a hot-reload picks up
+     * a re-defined backend.
+     */
+    replace(handle: H): void;
+}
+/**
+ * Optional metadata that handles MAY expose on a `capabilities` field
+ * (per AIP-43 § Capability metadata namespace). The registry does NOT
+ * validate the shape — capabilities are opaque to the catalog. This
+ * type is a documentation hint for hosts that want to converge on a
+ * common namespace.
+ */
+interface SuggestedCapabilities {
+    /** Can the bytes be mounted into a sandbox? (storage) */
+    bridgeable?: boolean;
+    /** How a sandbox sees the bytes when bridgeable. */
+    transport?: "symlink" | "fuse" | "mcp" | "tunnel" | (string & {});
+    /** Backend ids of the other family that compose cleanly. */
+    pairsWith?: string[];
+    /**
+     * Can a remote host reach this backend? `false` for `local-ide` /
+     * loopback `local-daemon` setups where the server can't reach the
+     * user's machine without a tunnel.
+     */
+    serverReachable?: boolean;
+}
+/** Thrown by `register(...)` when the key is already taken. */
+declare class RegistryDuplicateError extends Error {
+    readonly code: "registry_duplicate";
+    constructor(family: string, id: string);
+}
+/** Thrown by `replace(...)` when no handle exists at the resolved key. */
+declare class RegistryNotFoundError extends Error {
+    readonly code: "registry_not_found";
+    constructor(family: string, id: string);
+}
+/**
+ * Thrown when `keyBy` fails to derive a key (returns empty string,
+ * undefined, or throws). The registry can't store unkeyed handles.
+ */
+declare class RegistryKeyError extends Error {
+    readonly code: "registry_key_error";
+    constructor(family: string, reason: string);
+}
+
+/**
+ * AIP-43 REGISTRY — `createRegistry<H>()` reference implementation.
+ *
+ * In-memory, insertion-ordered, duplicate-refusing catalog of doctype
+ * handles. Type-parametric so the same impl works for STORAGE
+ * handles, SANDBOX handles, OPERATOR handles, EXTENSION handles —
+ * whatever the host registers.
+ *
+ * Storage: a `Map<string, H>`. Insertion order is the iteration
+ * order JS guarantees on Maps; `list()` and `entries()` rely on it.
+ */
+
+declare function createRegistry<H>(options: RegistryOptions<H>): Registry<H>;
+
+/**
+ * @agentproto/registry — AIP-43 reference implementation.
+ *
+ * A type-parametric in-memory catalog that collects N defineX'd
+ * doctype handles (storage, sandbox, operator, extension, …) and
+ * exposes a uniform lookup surface. Replaces hand-rolled per-host
+ * registries with one shape that works for every doctype family.
+ *
+ * @see https://agentproto.sh/docs/aip-43
+ */
+declare const SPEC_NAME: "agentregistry/v1";
+declare const SPEC_VERSION: "1.0.0-alpha";
+
+export { type Registry, RegistryDuplicateError, RegistryKeyError, RegistryNotFoundError, type RegistryOptions, SPEC_NAME, SPEC_VERSION, type SuggestedCapabilities, createRegistry };

package/dist/index.mjs

@@ -0,0 +1,113 @@
+/**
+ * @agentproto/registry v0.1.0-alpha
+ * AIP-43 REGISTRY reference implementation.
+ */
+
+// src/types.ts
+var RegistryDuplicateError = class extends Error {
+  code = "registry_duplicate";
+  constructor(family, id) {
+    super(
+      `[registry/${family}] handle '${id}' is already registered. Call unregister('${id}') first if replacement is intentional, or replace(handle) to swap atomically.`
+    );
+    this.name = "RegistryDuplicateError";
+  }
+};
+var RegistryNotFoundError = class extends Error {
+  code = "registry_not_found";
+  constructor(family, id) {
+    super(
+      `[registry/${family}] handle '${id}' is not registered; replace() requires an existing entry. Use register() for new handles.`
+    );
+    this.name = "RegistryNotFoundError";
+  }
+};
+var RegistryKeyError = class extends Error {
+  code = "registry_key_error";
+  constructor(family, reason) {
+    super(`[registry/${family}] ${reason}`);
+    this.name = "RegistryKeyError";
+  }
+};
+
+// src/create-registry.ts
+function defaultKeyBy(handle) {
+  if (!handle || typeof handle !== "object") return null;
+  const h = handle;
+  if (typeof h.id === "string" && h.id.length > 0) return h.id;
+  if (typeof h.provider === "string" && h.provider.length > 0) return h.provider;
+  if (typeof h.slug === "string" && h.slug.length > 0) return h.slug;
+  return null;
+}
+function createRegistry(options) {
+  const { family } = options;
+  const keyBy = options.keyBy ?? ((handle) => defaultKeyBy(handle) ?? "");
+  const entries = /* @__PURE__ */ new Map();
+  function resolveKey(handle) {
+    let key;
+    try {
+      key = keyBy(handle);
+    } catch (err) {
+      throw new RegistryKeyError(
+        family,
+        `keyBy threw while computing the key for a handle: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    if (typeof key !== "string" || key.length === 0) {
+      throw new RegistryKeyError(
+        family,
+        `keyBy returned ${key === "" ? "an empty string" : key === void 0 ? "undefined" : key === null ? "null" : `a non-string (${typeof key})`} for a handle. Provide an explicit \`keyBy\` in the registry options or set \`id\`/\`provider\`/\`slug\` on the handle.`
+      );
+    }
+    return key;
+  }
+  return {
+    register(handle) {
+      const key = resolveKey(handle);
+      if (entries.has(key)) {
+        throw new RegistryDuplicateError(family, key);
+      }
+      entries.set(key, handle);
+    },
+    has(id) {
+      return entries.has(id);
+    },
+    count() {
+      return entries.size;
+    },
+    get(id) {
+      return entries.get(id);
+    },
+    list() {
+      return Array.from(entries.values());
+    },
+    entries() {
+      return Array.from(entries.entries());
+    },
+    lookup(predicate) {
+      const out = [];
+      for (const handle of entries.values()) {
+        if (predicate(handle)) out.push(handle);
+      }
+      return out;
+    },
+    unregister(id) {
+      return entries.delete(id);
+    },
+    replace(handle) {
+      const key = resolveKey(handle);
+      if (!entries.has(key)) {
+        throw new RegistryNotFoundError(family, key);
+      }
+      entries.set(key, handle);
+    }
+  };
+}
+
+// src/index.ts
+var SPEC_NAME = "agentregistry/v1";
+var SPEC_VERSION = "1.0.0-alpha";
+
+export { RegistryDuplicateError, RegistryKeyError, RegistryNotFoundError, SPEC_NAME, SPEC_VERSION, createRegistry };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts","../src/create-registry.ts","../src/index.ts"],"names":[],"mappings":"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","file":"index.mjs","sourcesContent":["/**\n * AIP-43 REGISTRY — public types.\n *\n * The registry is type-parametric over a doctype handle `H`. The\n * package itself doesn't know what STORAGE / SANDBOX / OPERATOR\n * handles look like — it just relies on a `keyBy(handle) => string`\n * selector and treats `handle.capabilities` (if present) as opaque\n * metadata for `lookup()` queries.\n */\n\nexport interface RegistryOptions<H> {\n  /**\n   * Informational label used in error messages and (when discovery\n   * hooks are enabled) MCP tool names. Common values: `\"storage\"`,\n   * `\"sandbox\"`, `\"operator\"`. Doesn't affect lookup semantics.\n   */\n  family: string\n  /**\n   * How to derive the registry key from a handle. Required when the\n   * handle type doesn't expose a recognisable id field; the default\n   * resolution (per AIP-43 § Identity) inspects `handle.id`,\n   * `handle.provider`, `handle.slug` in priority order.\n   */\n  keyBy?: (handle: H) => string\n}\n\nexport interface Registry<H> {\n  /**\n   * Add a handle. Throws `RegistryDuplicateError` if the resolved key\n   * is already present — silent overwrite is unsafe (a second\n   * `defineStorage({ provider: \"s3\" })` shadowing the first is the\n   * exact bug class the registry exists to surface).\n   */\n  register(handle: H): void\n\n  /** Returns true if the resolved key is registered. */\n  has(id: string): boolean\n\n  /** Number of handles currently registered. */\n  count(): number\n\n  /** Get the handle by id. Returns undefined if absent. */\n  get(id: string): H | undefined\n\n  /** Every handle currently registered, insertion-ordered. */\n  list(): readonly H[]\n\n  /** Every `[id, handle]` pair, insertion-ordered. */\n  entries(): ReadonlyArray<readonly [string, H]>\n\n  /**\n   * Every handle matching `predicate`. Predicate runs in registration\n   * order; ties are broken by insertion order.\n   */\n  lookup(predicate: (handle: H) => boolean): readonly H[]\n\n  /**\n   * Remove `id` from the registry. Returns true if a handle was\n   * removed. Use sparingly — registries are intended to be\n   * boot-time-stable.\n   */\n  unregister(id: string): boolean\n\n  /**\n   * Replace an existing handle. Throws `RegistryNotFoundError` if no\n   * handle exists at `keyBy(handle)`. Use when a hot-reload picks up\n   * a re-defined backend.\n   */\n  replace(handle: H): void\n}\n\n/**\n * Optional metadata that handles MAY expose on a `capabilities` field\n * (per AIP-43 § Capability metadata namespace). The registry does NOT\n * validate the shape — capabilities are opaque to the catalog. This\n * type is a documentation hint for hosts that want to converge on a\n * common namespace.\n */\nexport interface SuggestedCapabilities {\n  /** Can the bytes be mounted into a sandbox? (storage) */\n  bridgeable?: boolean\n  /** How a sandbox sees the bytes when bridgeable. */\n  transport?: \"symlink\" | \"fuse\" | \"mcp\" | \"tunnel\" | (string & {})\n  /** Backend ids of the other family that compose cleanly. */\n  pairsWith?: string[]\n  /**\n   * Can a remote host reach this backend? `false` for `local-ide` /\n   * loopback `local-daemon` setups where the server can't reach the\n   * user's machine without a tunnel.\n   */\n  serverReachable?: boolean\n}\n\n/** Thrown by `register(...)` when the key is already taken. */\nexport class RegistryDuplicateError extends Error {\n  readonly code = \"registry_duplicate\" as const\n  constructor(family: string, id: string) {\n    super(\n      `[registry/${family}] handle '${id}' is already registered. ` +\n        `Call unregister('${id}') first if replacement is intentional, ` +\n        `or replace(handle) to swap atomically.`,\n    )\n    this.name = \"RegistryDuplicateError\"\n  }\n}\n\n/** Thrown by `replace(...)` when no handle exists at the resolved key. */\nexport class RegistryNotFoundError extends Error {\n  readonly code = \"registry_not_found\" as const\n  constructor(family: string, id: string) {\n    super(\n      `[registry/${family}] handle '${id}' is not registered; ` +\n        `replace() requires an existing entry. Use register() for new handles.`,\n    )\n    this.name = \"RegistryNotFoundError\"\n  }\n}\n\n/**\n * Thrown when `keyBy` fails to derive a key (returns empty string,\n * undefined, or throws). The registry can't store unkeyed handles.\n */\nexport class RegistryKeyError extends Error {\n  readonly code = \"registry_key_error\" as const\n  constructor(family: string, reason: string) {\n    super(`[registry/${family}] ${reason}`)\n    this.name = \"RegistryKeyError\"\n  }\n}\n","/**\n * AIP-43 REGISTRY — `createRegistry<H>()` reference implementation.\n *\n * In-memory, insertion-ordered, duplicate-refusing catalog of doctype\n * handles. Type-parametric so the same impl works for STORAGE\n * handles, SANDBOX handles, OPERATOR handles, EXTENSION handles —\n * whatever the host registers.\n *\n * Storage: a `Map<string, H>`. Insertion order is the iteration\n * order JS guarantees on Maps; `list()` and `entries()` rely on it.\n */\n\nimport {\n  RegistryDuplicateError,\n  RegistryKeyError,\n  RegistryNotFoundError,\n  type Registry,\n  type RegistryOptions,\n} from \"./types.js\"\n\n/**\n * Default key resolution per AIP-43 § Identity:\n *   1. `handle.id` (standalone doctype manifests)\n *   2. `handle.provider` (STORAGE / SANDBOX handles)\n *   3. `handle.slug` (EXTENSION handles)\n *\n * Returns null when none of the above are non-empty strings — the\n * caller raises `RegistryKeyError` in that case.\n */\nfunction defaultKeyBy<H>(handle: H): string | null {\n  if (!handle || typeof handle !== \"object\") return null\n  const h = handle as { id?: unknown; provider?: unknown; slug?: unknown }\n  if (typeof h.id === \"string\" && h.id.length > 0) return h.id\n  if (typeof h.provider === \"string\" && h.provider.length > 0) return h.provider\n  if (typeof h.slug === \"string\" && h.slug.length > 0) return h.slug\n  return null\n}\n\nexport function createRegistry<H>(options: RegistryOptions<H>): Registry<H> {\n  const { family } = options\n  const keyBy = options.keyBy ?? ((handle: H) => defaultKeyBy(handle) ?? \"\")\n  const entries = new Map<string, H>()\n\n  function resolveKey(handle: H): string {\n    let key: string\n    try {\n      key = keyBy(handle)\n    } catch (err) {\n      throw new RegistryKeyError(\n        family,\n        `keyBy threw while computing the key for a handle: ${\n          err instanceof Error ? err.message : String(err)\n        }`,\n      )\n    }\n    if (typeof key !== \"string\" || key.length === 0) {\n      throw new RegistryKeyError(\n        family,\n        `keyBy returned ${\n          key === \"\"\n            ? \"an empty string\"\n            : key === undefined\n              ? \"undefined\"\n              : key === null\n                ? \"null\"\n                : `a non-string (${typeof key})`\n        } for a handle. Provide an explicit \\`keyBy\\` in the registry options or set \\`id\\`/\\`provider\\`/\\`slug\\` on the handle.`,\n      )\n    }\n    return key\n  }\n\n  return {\n    register(handle) {\n      const key = resolveKey(handle)\n      if (entries.has(key)) {\n        throw new RegistryDuplicateError(family, key)\n      }\n      entries.set(key, handle)\n    },\n\n    has(id) {\n      return entries.has(id)\n    },\n\n    count() {\n      return entries.size\n    },\n\n    get(id) {\n      return entries.get(id)\n    },\n\n    list() {\n      return Array.from(entries.values())\n    },\n\n    entries() {\n      return Array.from(entries.entries())\n    },\n\n    lookup(predicate) {\n      const out: H[] = []\n      for (const handle of entries.values()) {\n        if (predicate(handle)) out.push(handle)\n      }\n      return out\n    },\n\n    unregister(id) {\n      return entries.delete(id)\n    },\n\n    replace(handle) {\n      const key = resolveKey(handle)\n      if (!entries.has(key)) {\n        throw new RegistryNotFoundError(family, key)\n      }\n      entries.set(key, handle)\n    },\n  }\n}\n","/**\n * @agentproto/registry — AIP-43 reference implementation.\n *\n * A type-parametric in-memory catalog that collects N defineX'd\n * doctype handles (storage, sandbox, operator, extension, …) and\n * exposes a uniform lookup surface. Replaces hand-rolled per-host\n * registries with one shape that works for every doctype family.\n *\n * @see https://agentproto.sh/docs/aip-43\n */\n\nexport const SPEC_NAME = \"agentregistry/v1\" as const\nexport const SPEC_VERSION = \"1.0.0-alpha\" as const\n\nexport { createRegistry } from \"./create-registry.js\"\nexport {\n  RegistryDuplicateError,\n  RegistryKeyError,\n  RegistryNotFoundError,\n  type Registry,\n  type RegistryOptions,\n  type SuggestedCapabilities,\n} from \"./types.js\"\n"]}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@agentproto/registry",
+  "version": "0.1.0-alpha.1",
+  "description": "@agentproto/registry — AIP-43 reference implementation. A type-parametric in-memory catalog that collects N defineX'd doctype handles (storage, sandbox, operator, extension, ...) and exposes a uniform lookup surface. One impl, every doctype family. Replaces hand-rolled per-host registries.",
+  "keywords": [
+    "agentproto",
+    "aip-43",
+    "registry",
+    "open-standard",
+    "agentic"
+  ],
+  "homepage": "https://agentproto.sh/docs/aip-43",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agentproto/ts",
+    "directory": "packages/registry"
+  },
+  "bugs": {
+    "url": "https://github.com/agentproto/ts/issues"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.mjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.2",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4",
+    "@agentproto/tooling": "0.1.0-alpha.0"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}