@opengeni/tool-gateway 0.1.0-canary.0

package/dist/index.js

@@ -0,0 +1,663 @@
+// src/index.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+import Ajv from "ajv";
+import Ajv2019 from "ajv/dist/2019.js";
+import Ajv2020 from "ajv/dist/2020.js";
+import {
+  TOOL_GATEWAY_CATALOG_VERSION,
+  ToolGatewayCallRequest,
+  ToolGatewayCatalog as ToolGatewayCatalog2,
+  ToolGatewayCatalogEntry,
+  ToolGatewayResult,
+  isToolResultSpilledReceipt
+} from "@opengeni/contracts";
+
+// src/catalog.ts
+import { createHash } from "crypto";
+import {
+  ATTEMPT_TOOL_CATALOG_MAX_BYTES,
+  ToolGatewayCatalog
+} from "@opengeni/contracts";
+
+// src/errors.ts
+var ToolGatewayCatalogStaleError = class extends Error {
+  code = "catalog_stale";
+  constructor() {
+    super("Tool catalog is stale for the active gateway");
+    this.name = "ToolGatewayCatalogStaleError";
+  }
+};
+var ToolGatewayToolNotFoundError = class extends Error {
+  code = "tool_not_found";
+  constructor() {
+    super("Tool is not present in the active gateway catalog");
+    this.name = "ToolGatewayToolNotFoundError";
+  }
+};
+var ToolGatewayApprovalRequiredError = class extends Error {
+  code = "approval_required";
+  constructor() {
+    super("Tool requires human approval");
+    this.name = "ToolGatewayApprovalRequiredError";
+  }
+};
+var ToolGatewayCatalogIntegrityError = class extends Error {
+  code = "catalog_integrity_failed";
+  constructor() {
+    super("Tool catalog digest does not match its authoritative content");
+    this.name = "ToolGatewayCatalogIntegrityError";
+  }
+};
+var ToolGatewayCatalogTooLargeError = class extends Error {
+  code = "catalog_too_large";
+  constructor() {
+    super("Tool catalog exceeds the maximum serialized size");
+    this.name = "ToolGatewayCatalogTooLargeError";
+  }
+};
+var ToolGatewayPathCollisionError = class extends Error {
+  code = "tool_path_collision";
+  constructor(path, kind) {
+    super(
+      kind === "extends_leaf" ? `Tool path ${path.join(".")} extends a tool leaf` : `Tool path ${path.join(".")} collides`
+    );
+    this.name = "ToolGatewayPathCollisionError";
+  }
+};
+var ToolGatewayInputValidationError = class extends Error {
+  code = "invalid_tool_arguments";
+  constructor() {
+    super("Tool arguments do not match the gateway catalog input schema");
+    this.name = "ToolGatewayInputValidationError";
+  }
+};
+var ToolGatewayOutputValidationError = class extends Error {
+  code = "invalid_tool_result";
+  constructor() {
+    super("Tool result does not match the gateway catalog output schema");
+    this.name = "ToolGatewayOutputValidationError";
+  }
+};
+
+// src/catalog.ts
+function digestToolGatewayCatalog(catalog) {
+  const { createdAt: _createdAt, ...authoritative } = catalog;
+  return digestCanonicalJson(authoritative);
+}
+function parseVerifiedToolGatewayCatalog(input) {
+  const catalog = ToolGatewayCatalog.parse(input);
+  assertCatalogSize(catalog);
+  const { digest, ...unsigned } = catalog;
+  if (digestToolGatewayCatalog(unsigned) !== digest) {
+    throw new ToolGatewayCatalogIntegrityError();
+  }
+  return catalog;
+}
+function digestCanonicalJson(value) {
+  return createHash("sha256").update(JSON.stringify(canonicalJsonValue(value)), "utf8").digest("hex");
+}
+function compareCanonicalStrings(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function assertToolGatewayCatalogSize(catalog) {
+  assertCatalogSize(catalog);
+}
+function assertCatalogSize(catalog) {
+  if (new TextEncoder().encode(JSON.stringify(catalog)).byteLength > ATTEMPT_TOOL_CATALOG_MAX_BYTES) {
+    throw new ToolGatewayCatalogTooLargeError();
+  }
+}
+function canonicalJsonValue(value) {
+  if (Array.isArray(value)) return value.map(canonicalJsonValue);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => compareCanonicalStrings(left, right)).map(([key, entry]) => [key, canonicalJsonValue(entry)])
+    );
+  }
+  return value;
+}
+
+// src/declarations.ts
+function generateToolGatewayDeclarations(catalog, options = {}) {
+  const verified = parseVerifiedToolGatewayCatalog(catalog);
+  return generateToolDeclarations(
+    { digest: verified.digest, entries: verified.entries },
+    {
+      moduleSpecifier: options.moduleSpecifier ?? "@opengeni/sdk",
+      interfaceName: options.interfaceName ?? "OpenGeniGeneratedTools",
+      callOptionsType: "OpenGeniToolCallOptions",
+      fallbackResultType: "ToolGatewayResult",
+      generatedBy: "@opengeni/tool-gateway",
+      catalogDigestLabel: "Tool catalog digest"
+    }
+  );
+}
+function generateToolDeclarations(catalog, options) {
+  const root = namespaceNode();
+  for (const entry of catalog.entries) insertEntry(root, entry);
+  return [
+    `// Generated by ${options.generatedBy}. Do not edit.`,
+    `// ${options.catalogDigestLabel ?? "Tool catalog digest"}: ${catalog.digest}`,
+    `import type { ${options.callOptionsType}, ${options.fallbackResultType} } from ${JSON.stringify(options.moduleSpecifier)};`,
+    "",
+    `declare module ${JSON.stringify(options.moduleSpecifier)} {`,
+    `  interface ${options.interfaceName} {`,
+    ...renderChildren(root, 4, options),
+    "  }",
+    "}",
+    "",
+    "export {};",
+    ""
+  ].join("\n");
+}
+function jsonSchemaToTypeScript(schema) {
+  return schemaType(schema, schema, /* @__PURE__ */ new Set(), 0);
+}
+function namespaceNode() {
+  return { children: /* @__PURE__ */ new Map(), entry: null };
+}
+function insertEntry(root, entry) {
+  let node = root;
+  for (const [index, segment] of entry.codemodePath.entries()) {
+    if (node.entry) {
+      throw new ToolGatewayPathCollisionError(entry.codemodePath, "extends_leaf");
+    }
+    let child = node.children.get(segment);
+    if (!child) {
+      child = namespaceNode();
+      node.children.set(segment, child);
+    }
+    node = child;
+    if (index === entry.codemodePath.length - 1) {
+      if (node.entry || node.children.size > 0) {
+        throw new ToolGatewayPathCollisionError(entry.codemodePath, "collision");
+      }
+      node.entry = entry;
+    }
+  }
+}
+function renderChildren(node, indent, options) {
+  const lines = [];
+  for (const [name, child] of [...node.children].sort(
+    ([left], [right]) => compareCanonicalStrings(left, right)
+  )) {
+    if (child.entry) {
+      const entry = child.entry;
+      const input = jsonSchemaToTypeScript(entry.inputSchema);
+      const output = entry.outputSchema ? jsonSchemaToTypeScript(entry.outputSchema) : options.fallbackResultType;
+      const description = boundedDoc(entry.description ?? entry.title);
+      if (description) lines.push(...renderDoc(description, indent));
+      lines.push(`${spaces(indent)}readonly ${name}: (`);
+      lines.push(
+        `${spaces(indent + 2)}argumentsValue${rootObjectArgumentsAreOptional(entry.inputSchema) ? "?" : ""}: ${input},`
+      );
+      lines.push(`${spaces(indent + 2)}options?: ${options.callOptionsType},`);
+      lines.push(`${spaces(indent)}) => Promise<${output}>;`);
+      continue;
+    }
+    lines.push(`${spaces(indent)}readonly ${name}: {`);
+    lines.push(...renderChildren(child, indent + 2, options));
+    lines.push(`${spaces(indent)}};`);
+  }
+  return lines;
+}
+function rootObjectArgumentsAreOptional(schema) {
+  if (!isObject(schema)) return false;
+  const required = Array.isArray(schema.required) ? schema.required.filter((value) => typeof value === "string") : [];
+  return required.length === 0 && (schema.type === "object" || isObject(schema.properties));
+}
+function schemaType(schema, root, resolving, depth) {
+  if (depth > 48 || schema === true) return "unknown";
+  if (schema === false) return "never";
+  if (!isObject(schema)) return "unknown";
+  if (typeof schema.$ref === "string") {
+    if (!schema.$ref.startsWith("#/") || resolving.has(schema.$ref)) return "unknown";
+    const resolved = resolveLocalReference(root, schema.$ref);
+    if (resolved === void 0) return "unknown";
+    const next = new Set(resolving);
+    next.add(schema.$ref);
+    return schemaType(resolved, root, next, depth + 1);
+  }
+  if (Object.hasOwn(schema, "const")) return literalType(schema.const);
+  if (Array.isArray(schema.enum)) return union(schema.enum.map(literalType));
+  const composites = [];
+  if (Array.isArray(schema.oneOf)) {
+    composites.push(
+      union(schema.oneOf.map((part) => schemaType(part, root, resolving, depth + 1)))
+    );
+  }
+  if (Array.isArray(schema.anyOf)) {
+    composites.push(
+      union(schema.anyOf.map((part) => schemaType(part, root, resolving, depth + 1)))
+    );
+  }
+  if (Array.isArray(schema.allOf)) {
+    composites.push(
+      intersection(schema.allOf.map((part) => schemaType(part, root, resolving, depth + 1)))
+    );
+  }
+  if (composites.length > 0) {
+    const composed = intersection(composites);
+    return schema.nullable === true ? union([composed, "null"]) : composed;
+  }
+  const types = Array.isArray(schema.type) ? schema.type.filter((value) => typeof value === "string") : typeof schema.type === "string" ? [schema.type] : inferredTypes(schema);
+  const rendered = types.map((type) => typeType(type, schema, root, resolving, depth + 1));
+  if (schema.nullable === true) rendered.push("null");
+  return union(rendered.length > 0 ? rendered : ["unknown"]);
+}
+function typeType(type, schema, root, resolving, depth) {
+  if (type === "null" || type === "boolean" || type === "string") return type;
+  if (type === "integer" || type === "number") return "number";
+  if (type === "array") return arrayType(schema, root, resolving, depth);
+  if (type !== "object") return "unknown";
+  return objectType(schema, root, resolving, depth);
+}
+function arrayType(schema, root, resolving, depth) {
+  if (Array.isArray(schema.prefixItems)) {
+    const tuple = schema.prefixItems.map((item2) => schemaType(item2, root, resolving, depth + 1));
+    if (schema.items === false) return `readonly [${tuple.join(", ")}]`;
+    const rest = schema.items === void 0 || schema.items === true ? "unknown" : schemaType(schema.items, root, resolving, depth + 1);
+    return `readonly [${tuple.join(", ")}${tuple.length > 0 ? ", " : ""}...${rest}[]]`;
+  }
+  const item = schema.items === void 0 || schema.items === true ? "unknown" : schemaType(schema.items, root, resolving, depth + 1);
+  return `readonly (${item})[]`;
+}
+function objectType(schema, root, resolving, depth) {
+  const properties = isObject(schema.properties) ? schema.properties : {};
+  const required = new Set(
+    Array.isArray(schema.required) ? schema.required.filter((value) => typeof value === "string") : []
+  );
+  const entries = Object.entries(properties).sort(
+    ([left], [right]) => compareCanonicalStrings(left, right)
+  );
+  const fields = entries.map(
+    ([name, value]) => `readonly ${identifierOrQuoted(name)}${required.has(name) ? "" : "?"}: ${schemaType(value, root, resolving, depth + 1)}`
+  );
+  for (const missing of [...required].filter((name) => !Object.hasOwn(properties, name)).sort(compareCanonicalStrings)) {
+    fields.push(`readonly ${identifierOrQuoted(missing)}: unknown`);
+  }
+  if (schema.additionalProperties !== false) {
+    if (entries.length === 0 && schema.additionalProperties !== void 0 && schema.additionalProperties !== true) {
+      return `Readonly<Record<string, ${schemaType(
+        schema.additionalProperties,
+        root,
+        resolving,
+        depth + 1
+      )}>>`;
+    }
+    fields.push("readonly [key: string]: unknown");
+  }
+  return fields.length === 0 ? "Record<string, never>" : `{ ${fields.join("; ")} }`;
+}
+function inferredTypes(schema) {
+  if (isObject(schema.properties) || Object.hasOwn(schema, "additionalProperties")) {
+    return ["object"];
+  }
+  if (Object.hasOwn(schema, "items") || Array.isArray(schema.prefixItems)) return ["array"];
+  return [];
+}
+function resolveLocalReference(root, reference) {
+  let current = root;
+  for (const encoded of reference.slice(2).split("/")) {
+    if (!isObject(current)) return void 0;
+    const segment = encoded.replace(/~1/gu, "/").replace(/~0/gu, "~");
+    if (!Object.hasOwn(current, segment)) return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function literalType(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) return `readonly [${value.map(literalType).join(", ")}]`;
+  if (isObject(value)) {
+    return `{ ${Object.entries(value).sort(([left], [right]) => compareCanonicalStrings(left, right)).map(([key, child]) => `readonly ${identifierOrQuoted(key)}: ${literalType(child)}`).join("; ")} }`;
+  }
+  return "unknown";
+}
+function union(values) {
+  const unique = [...new Set(values)];
+  if (unique.includes("unknown")) return "unknown";
+  if (unique.length === 0) return "never";
+  return unique.length === 1 ? unique[0] : unique.map(parenthesizeComposite).join(" | ");
+}
+function intersection(values) {
+  const unique = [...new Set(values.filter((value) => value !== "unknown"))];
+  return unique.length === 0 ? "unknown" : unique.length === 1 ? unique[0] : unique.map(parenthesizeComposite).join(" & ");
+}
+function parenthesizeComposite(value) {
+  return /[|&]/u.test(value) ? `(${value})` : value;
+}
+function identifierOrQuoted(value) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(value) ? value : JSON.stringify(value);
+}
+function boundedDoc(value) {
+  if (!value) return null;
+  const normalized = value.replace(/\s+/gu, " ").trim().replace(/\*\//gu, "*\\/");
+  if (!normalized) return null;
+  return normalized.length <= 512 ? normalized : `${normalized.slice(0, 509)}...`;
+}
+function renderDoc(value, indent) {
+  return [`${spaces(indent)}/** ${value} */`];
+}
+function spaces(count) {
+  return " ".repeat(count);
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/index.ts
+var PreparedToolGatewayDefinitions = class {
+  constructor(definitions) {
+    this.definitions = definitions;
+    this.entries = definitions.map(({ entry }) => entry);
+  }
+  entries;
+  create(input) {
+    return new ToolGateway(
+      input.catalogDigest,
+      this.definitions,
+      input.authorize,
+      input.requireApproval,
+      input.confirmModelApproval
+    );
+  }
+};
+var ToolGateway = class {
+  constructor(catalogDigest, definitions, authorize, requireApproval, confirmModelApproval) {
+    this.catalogDigest = catalogDigest;
+    this.authorize = authorize;
+    this.requireApproval = requireApproval;
+    this.confirmModelApproval = confirmModelApproval;
+    for (const definition of definitions) {
+      this.byIdentity.set(identityKey(definition.entry.identity), definition);
+      this.byModelName.set(definition.entry.modelName, definition);
+    }
+  }
+  byIdentity = /* @__PURE__ */ new Map();
+  byModelName = /* @__PURE__ */ new Map();
+  async call(input, context = {}) {
+    return await (await this.prepareCallWithModelApproval(input, context, false)).execute();
+  }
+  async prepareCall(input, context = {}) {
+    return await this.prepareCallWithModelApproval(input, context, false);
+  }
+  async prepareCallWithModelApproval(input, context, modelApprovalConfirmed) {
+    const request = ToolGatewayCallRequest.parse({
+      operationId: input.operationId,
+      catalogDigest: input.catalogDigest,
+      identity: input.identity,
+      arguments: input.arguments
+    });
+    const operationId = request.operationId ?? input.operationId;
+    const caller = input.caller;
+    if (request.catalogDigest !== this.catalogDigest) {
+      throw new ToolGatewayCatalogStaleError();
+    }
+    const definition = this.byIdentity.get(identityKey(request.identity));
+    if (!definition) {
+      throw new ToolGatewayToolNotFoundError();
+    }
+    if (this.requireApproval?.(definition.entry, caller, context)) {
+      throw new ToolGatewayApprovalRequiredError();
+    }
+    if (!definition.validateInput(request.arguments)) {
+      throw new ToolGatewayInputValidationError();
+    }
+    if (caller.kind === "model" && definition.entry.approval === "human" && !modelApprovalConfirmed) {
+      throw new ToolGatewayApprovalRequiredError();
+    }
+    const call = {
+      operationId,
+      catalogDigest: request.catalogDigest,
+      identity: request.identity,
+      arguments: request.arguments,
+      caller
+    };
+    await this.authorize?.({ call, entry: definition.entry });
+    if (definition.entry.approval === "human") {
+      await definition.preflightCall?.({
+        call,
+        entry: definition.entry,
+        context
+      });
+    }
+    const lifecycle = await definition.lifecycle?.prepare({
+      call,
+      entry: definition.entry,
+      context
+    });
+    return {
+      call,
+      entry: definition.entry,
+      approvalAuthorityDigest: definition.approvalAuthorityDigest ?? digestCanonicalJson({
+        version: 1,
+        catalogDigest: this.catalogDigest,
+        identity: definition.entry.identity
+      }),
+      execute: async () => {
+        await lifecycle?.begin?.();
+        let result;
+        try {
+          result = ToolGatewayResult.parse(
+            await definition.execute(request.arguments, {
+              operationId,
+              caller,
+              ...context.transportMeta === void 0 ? {} : { transportMeta: context.transportMeta },
+              ...context.signal === void 0 ? {} : { signal: context.signal }
+            })
+          );
+          if (!result.isError && definition.validateOutput) {
+            const outputMatchesSchema = result.structuredContent !== void 0 && definition.validateOutput(result.structuredContent);
+            if (!outputMatchesSchema && !isToolResultSpilledReceipt(result.structuredContent)) {
+              throw new ToolGatewayOutputValidationError();
+            }
+          }
+        } catch (error) {
+          await lifecycle?.complete?.({ outcome: "failed", error });
+          throw error;
+        }
+        await lifecycle?.complete?.({ outcome: "completed", result });
+        return result;
+      }
+    };
+  }
+  async callModel(input) {
+    const definition = this.byModelName.get(input.modelName);
+    if (!definition) {
+      throw new ToolGatewayToolNotFoundError();
+    }
+    const call = {
+      operationId: input.operationId ?? randomUUID(),
+      catalogDigest: this.catalogDigest,
+      identity: definition.entry.identity,
+      arguments: input.arguments,
+      caller: { kind: "model", subjectId: input.subjectId }
+    };
+    const context = {
+      ...input.transportMeta === void 0 ? {} : { transportMeta: input.transportMeta },
+      ...input.signal === void 0 ? {} : { signal: input.signal }
+    };
+    const modelApprovalConfirmed = definition.entry.approval === "human" && this.confirmModelApproval?.({
+      entry: definition.entry,
+      modelName: input.modelName,
+      subjectId: input.subjectId
+    }) === true;
+    return await (await this.prepareCallWithModelApproval(call, context, modelApprovalConfirmed)).execute();
+  }
+};
+function prepareToolGatewayDefinitions(definitions) {
+  const paths = allocateToolPaths(definitions);
+  const schemaValidators = createSchemaValidators();
+  const compiled = definitions.map((definition, index) => {
+    const {
+      execute,
+      approvalAuthorityDigest,
+      requiresProviderPreflight: _requiresProviderPreflight,
+      preflightCall,
+      lifecycle,
+      codemodePath: _path,
+      ...entryInput
+    } = definition;
+    if (approvalAuthorityDigest !== void 0 && !/^[0-9a-f]{64}$/u.test(approvalAuthorityDigest)) {
+      throw new Error("Tool gateway approval authority digest must be lowercase SHA-256 hex");
+    }
+    const entry = ToolGatewayCatalogEntry.parse({
+      ...entryInput,
+      codemodePath: paths[index]
+    });
+    return {
+      entry,
+      execute,
+      approvalAuthorityDigest,
+      preflightCall,
+      lifecycle,
+      validateInput: compileCatalogSchema(schemaValidators, entry.inputSchema),
+      validateOutput: entry.outputSchema ? compileCatalogSchema(schemaValidators, entry.outputSchema) : null
+    };
+  });
+  return new PreparedToolGatewayDefinitions(compiled);
+}
+function createWorkspaceToolGateway(input) {
+  const prepared = prepareToolGatewayDefinitions(input.definitions);
+  const unsigned = {
+    version: TOOL_GATEWAY_CATALOG_VERSION,
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    generation: input.generation,
+    createdAt: (input.createdAt ?? /* @__PURE__ */ new Date()).toISOString(),
+    entries: [...prepared.entries]
+  };
+  const catalog = ToolGatewayCatalog2.parse({
+    ...unsigned,
+    digest: digestToolGatewayCatalog(unsigned)
+  });
+  assertToolGatewayCatalogSize(catalog);
+  return {
+    catalog,
+    gateway: prepared.create({
+      catalogDigest: catalog.digest,
+      ...input.authorize ? { authorize: input.authorize } : {},
+      ...input.requireApproval ? { requireApproval: input.requireApproval } : {}
+    })
+  };
+}
+var COMPILED_CATALOG_SCHEMA_CACHE_MAX_ENTRIES = 512;
+var compiledCatalogSchemaCache = /* @__PURE__ */ new Map();
+function createSchemaValidators() {
+  const options = {
+    allErrors: false,
+    coerceTypes: false,
+    strict: false,
+    useDefaults: false,
+    validateFormats: false
+  };
+  return {
+    draft7: new Ajv(options),
+    draft2019: new Ajv2019(options),
+    draft2020: new Ajv2020(options)
+  };
+}
+function compileCatalogSchema(validators, schema) {
+  const dialect = typeof schema.$schema === "string" ? schema.$schema : "";
+  const family = dialect.includes("2020-12") ? "2020-12" : dialect.includes("2019-09") ? "2019-09" : "draft7";
+  const cacheKey = `${family}:${digestCanonicalJson(schema)}`;
+  const cached = compiledCatalogSchemaCache.get(cacheKey);
+  if (cached) {
+    compiledCatalogSchemaCache.delete(cacheKey);
+    compiledCatalogSchemaCache.set(cacheKey, cached);
+    return cached;
+  }
+  const compiled = family === "2020-12" ? validators.draft2020.compile(schema) : family === "2019-09" ? validators.draft2019.compile(schema) : validators.draft7.compile(schema);
+  while (compiledCatalogSchemaCache.size >= COMPILED_CATALOG_SCHEMA_CACHE_MAX_ENTRIES) {
+    const oldest = compiledCatalogSchemaCache.keys().next().value;
+    if (oldest === void 0) break;
+    compiledCatalogSchemaCache.delete(oldest);
+  }
+  compiledCatalogSchemaCache.set(cacheKey, compiled);
+  return compiled;
+}
+function allocateToolPaths(definitions) {
+  const requested = definitions.map(
+    (definition) => definition.codemodePath?.length ? [...definition.codemodePath] : [definition.identity.serverId, definition.identity.toolName]
+  );
+  const bases = requested.map((path) => path.map(safeNamespaceSegment));
+  const allocated = bases.map((base, index) => {
+    const path = requested[index];
+    if (path.every((segment, segmentIndex) => segment === base[segmentIndex])) return base;
+    const suffix = `_${shortIdentityDigest(definitions[index].identity)}`;
+    const last = base.at(-1);
+    return [...base.slice(0, -1), `${last.slice(0, 128 - suffix.length)}${suffix}`];
+  });
+  assertNoToolPathCollisions(allocated);
+  return allocated;
+}
+function assertNoToolPathCollisions(paths) {
+  const root = { children: /* @__PURE__ */ new Map(), leaf: false };
+  const ordered = [...paths].sort(compareToolPaths);
+  for (const path of ordered) {
+    let node = root;
+    for (const [index, segment] of path.entries()) {
+      if (node.leaf) throw new ToolGatewayPathCollisionError(path, "extends_leaf");
+      let child = node.children.get(segment);
+      if (!child) {
+        child = { children: /* @__PURE__ */ new Map(), leaf: false };
+        node.children.set(segment, child);
+      }
+      node = child;
+      if (index === path.length - 1) {
+        if (node.leaf || node.children.size > 0) {
+          throw new ToolGatewayPathCollisionError(path, "collision");
+        }
+        node.leaf = true;
+      }
+    }
+  }
+}
+function compareToolPaths(left, right) {
+  const length = Math.min(left.length, right.length);
+  for (let index = 0; index < length; index += 1) {
+    const compared = compareCanonicalStrings(left[index], right[index]);
+    if (compared !== 0) return compared;
+  }
+  return left.length - right.length;
+}
+function safeNamespaceSegment(value) {
+  let normalized = value.replace(/[^A-Za-z0-9_$]/gu, "_");
+  if (!/^[A-Za-z_$]/u.test(normalized)) normalized = `_${normalized}`;
+  if (["__proto__", "prototype", "constructor"].includes(normalized)) {
+    normalized = `_${normalized}`;
+  }
+  return normalized.slice(0, 128) || "_";
+}
+function shortIdentityDigest(identity) {
+  return createHash2("sha256").update(identityKey(identity), "utf8").digest("hex").slice(0, 10);
+}
+function identityKey(identity) {
+  return `${identity.serverId}\0${identity.toolName}`;
+}
+export {
+  PreparedToolGatewayDefinitions,
+  ToolGateway,
+  ToolGatewayApprovalRequiredError,
+  ToolGatewayCatalogIntegrityError,
+  ToolGatewayCatalogStaleError,
+  ToolGatewayCatalogTooLargeError,
+  ToolGatewayInputValidationError,
+  ToolGatewayOutputValidationError,
+  ToolGatewayPathCollisionError,
+  ToolGatewayToolNotFoundError,
+  assertToolGatewayCatalogSize,
+  compareCanonicalStrings,
+  createWorkspaceToolGateway,
+  digestCanonicalJson,
+  digestToolGatewayCatalog,
+  generateToolDeclarations,
+  generateToolGatewayDeclarations,
+  jsonSchemaToTypeScript,
+  parseVerifiedToolGatewayCatalog,
+  prepareToolGatewayDefinitions
+};
+//# sourceMappingURL=index.js.map