@botbotgo/kit 1.0.106

package/dist/observability/Metrics.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Simple counter metric.
+ */
+export interface CounterValue {
+    name: string;
+    labels: Record<string, string>;
+    value: number;
+}
+/**
+ * Histogram bucket.
+ */
+export interface HistogramValue {
+    name: string;
+    labels: Record<string, string>;
+    count: number;
+    sum: number;
+    buckets: Map<number, number>;
+}
+/**
+ * Lightweight metrics collector for tool invocations.
+ * Provides counters and histograms with label support.
+ */
+export declare class Metrics {
+    private readonly counters;
+    private readonly histograms;
+    private readonly defaultBuckets;
+    /**
+     * Increment a counter.
+     */
+    increment(name: string, labels?: Record<string, string>, value?: number): void;
+    /**
+     * Record a value in a histogram.
+     */
+    observe(name: string, labels: Record<string, string>, value: number): void;
+    /**
+     * Get a counter value.
+     */
+    getCounter(name: string, labels?: Record<string, string>): number;
+    /**
+     * Get histogram stats.
+     */
+    getHistogram(name: string, labels: Record<string, string>): HistogramValue | undefined;
+    /**
+     * Get all counter values.
+     */
+    getAllCounters(): CounterValue[];
+    /**
+     * Get all histogram values.
+     */
+    getAllHistograms(): HistogramValue[];
+    /**
+     * Record standard tool invocation metrics.
+     */
+    recordInvocation(toolName: string, ok: boolean, durationMs: number): void;
+    /**
+     * Record a retry event.
+     */
+    recordRetry(toolName: string): void;
+    /**
+     * Record a policy denial.
+     */
+    recordPolicyDenied(toolName: string, reason: string): void;
+    /**
+     * Reset all metrics (for testing).
+     */
+    reset(): void;
+    private makeKey;
+    private parseKey;
+}
+//# sourceMappingURL=Metrics.d.ts.map

package/dist/observability/Metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Metrics.d.ts","sourceRoot":"","sources":["../../src/observability/Metrics.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9B;AAED;;;GAGG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;IACtD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAGvB;IAEJ,OAAO,CAAC,QAAQ,CAAC,cAAc,CAE7B;IAEF;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EAAE,KAAK,SAAI,GAAG,IAAI;IAK7E;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAY1E;;OAEG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GAAG,MAAM;IAIrE;;OAEG;IACH,YAAY,CACV,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,cAAc,GAAG,SAAS;IAa7B;;OAEG;IACH,cAAc,IAAI,YAAY,EAAE;IAShC;;OAEG;IACH,gBAAgB,IAAI,cAAc,EAAE;IAapC;;OAEG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAQzE;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAInC;;OAEG;IACH,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAI1D;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb,OAAO,CAAC,OAAO;IAQf,OAAO,CAAC,QAAQ;CAejB"}

package/dist/observability/Tracing.d.ts

@@ -0,0 +1,69 @@
+/**
+ * A trace span representing a unit of work.
+ */
+export interface Span {
+    spanId: string;
+    traceId: string;
+    parentSpanId?: string;
+    name: string;
+    startTime: number;
+    endTime?: number;
+    durationMs?: number;
+    status: "ok" | "error" | "in_progress";
+    attributes: Record<string, string | number | boolean>;
+    events: SpanEvent[];
+}
+/**
+ * An event within a span.
+ */
+export interface SpanEvent {
+    name: string;
+    timestamp: number;
+    attributes?: Record<string, string | number | boolean>;
+}
+/**
+ * Lightweight tracing system for tool invocation spans.
+ * Compatible with OpenTelemetry trace/span ID format.
+ */
+export declare class Tracing {
+    private readonly spans;
+    private readonly traceSpans;
+    /**
+     * Start a new span.
+     */
+    startSpan(options: {
+        name: string;
+        traceId?: string;
+        parentSpanId?: string;
+        attributes?: Record<string, string | number | boolean>;
+    }): Span;
+    /**
+     * End a span and calculate duration.
+     */
+    endSpan(spanId: string, status?: "ok" | "error"): Span | undefined;
+    /**
+     * Add an event to a span.
+     */
+    addEvent(spanId: string, name: string, attributes?: Record<string, string | number | boolean>): void;
+    /**
+     * Set attributes on a span.
+     */
+    setAttributes(spanId: string, attributes: Record<string, string | number | boolean>): void;
+    /**
+     * Get a span by ID.
+     */
+    getSpan(spanId: string): Span | undefined;
+    /**
+     * Get all spans for a trace.
+     */
+    getTrace(traceId: string): Span[];
+    /**
+     * Create a child span from a parent.
+     */
+    createChildSpan(parentSpanId: string, name: string, attributes?: Record<string, string | number | boolean>): Span | undefined;
+    /**
+     * Clear all traces (for testing).
+     */
+    clear(): void;
+}
+//# sourceMappingURL=Tracing.d.ts.map

package/dist/observability/Tracing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tracing.d.ts","sourceRoot":"","sources":["../../src/observability/Tracing.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,WAAW,IAAI;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,IAAI,GAAG,OAAO,GAAG,aAAa,CAAC;IACvC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;IACtD,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;CACxD;AAED;;;GAGG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA2B;IACjD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA+B;IAE1D;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;KACxD,GAAG,IAAI;IAqBR;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,IAAI,GAAG,OAAc,GAAG,IAAI,GAAG,SAAS;IAUxE;;OAEG;IACH,QAAQ,CACN,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GACrD,IAAI;IAMP;;OAEG;IACH,aAAa,CACX,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GACpD,IAAI;IAMP;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS;IAIzC;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,EAAE;IAOjC;;OAEG;IACH,eAAe,CACb,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GACrD,IAAI,GAAG,SAAS;IAWnB;;OAEG;IACH,KAAK,IAAI,IAAI;CAId"}

package/dist/sdk.cjs

@@ -0,0 +1,493 @@
+'use strict';
+
+var chunkBNIE2IKZ_cjs = require('./chunk-BNIE2IKZ.cjs');
+var chunkAGLGFQUW_cjs = require('./chunk-AGLGFQUW.cjs');
+var chunkJW4EMVTE_cjs = require('./chunk-JW4EMVTE.cjs');
+var promises = require('dns/promises');
+var async_hooks = require('async_hooks');
+var path4 = require('path');
+var url = require('url');
+var fs = require('fs');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path4__default = /*#__PURE__*/_interopDefault(path4);
+
+async function validateUrl(url, options) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw chunkAGLGFQUW_cjs.createTaggedError(
+      "HTTP_DISALLOWED_HOST",
+      `Invalid URL: ${url}`,
+      { url }
+    );
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw chunkAGLGFQUW_cjs.createTaggedError(
+      "HTTP_DISALLOWED_HOST",
+      `Protocol not allowed: ${parsed.protocol}. Only http: and https: are supported.`,
+      { url, protocol: parsed.protocol }
+    );
+  }
+  const hostname = parsed.hostname;
+  if (!isHostAllowed(hostname, options.allowedHosts)) {
+    throw chunkAGLGFQUW_cjs.createTaggedError(
+      "HTTP_DISALLOWED_HOST",
+      `Host "${hostname}" is not in the allowed hosts list`,
+      { url, hostname, allowedHosts: options.allowedHosts }
+    );
+  }
+  if (isHostBlocked(hostname, options.blockedHosts)) {
+    throw chunkAGLGFQUW_cjs.createTaggedError(
+      "HTTP_DISALLOWED_HOST",
+      `Host "${hostname}" is in the blocked hosts list`,
+      { url, hostname, blockedHosts: options.blockedHosts }
+    );
+  }
+  try {
+    const { address } = await promises.lookup(hostname);
+    if (isIpInBlockedCidrs(address, options.blockedCidrs)) {
+      throw chunkAGLGFQUW_cjs.createTaggedError(
+        "HTTP_DISALLOWED_HOST",
+        `Host "${hostname}" resolves to blocked IP: ${address}`,
+        { url, hostname, resolvedIp: address }
+      );
+    }
+  } catch (err) {
+    if (err instanceof Error && err.kind === "HTTP_DISALLOWED_HOST") {
+      throw err;
+    }
+    throw chunkAGLGFQUW_cjs.createTaggedError(
+      "HTTP_DISALLOWED_HOST",
+      `DNS resolution failed for host "${hostname}": ${err instanceof Error ? err.message : String(err)}`,
+      { url, hostname }
+    );
+  }
+  return parsed;
+}
+function isHostAllowed(hostname, allowedHosts) {
+  for (const pattern of allowedHosts) {
+    if (pattern === "*") {
+      return true;
+    }
+    if (pattern.startsWith("*.")) {
+      const suffix = pattern.slice(1);
+      if (hostname.endsWith(suffix) || hostname === pattern.slice(2)) {
+        return true;
+      }
+    } else if (hostname === pattern) {
+      return true;
+    }
+  }
+  return false;
+}
+function isHostBlocked(hostname, blockedHosts) {
+  for (const pattern of blockedHosts) {
+    if (pattern === "*") {
+      return true;
+    }
+    if (pattern.startsWith("*.")) {
+      const suffix = pattern.slice(1);
+      if (hostname.endsWith(suffix) || hostname === pattern.slice(2)) {
+        return true;
+      }
+    } else if (hostname === pattern) {
+      return true;
+    }
+  }
+  return false;
+}
+function isIpInBlockedCidrs(ip, cidrs) {
+  const normalizedIp = normalizeIp(ip);
+  if (!normalizedIp) return false;
+  for (const cidr of cidrs) {
+    if (cidr.includes(":")) {
+      if (!ip.includes(":")) continue;
+      if (isIpv6InCidr(ip, cidr)) return true;
+    } else {
+      if (isIpv4InCidr(normalizedIp, cidr)) return true;
+    }
+  }
+  return false;
+}
+function normalizeIp(ip) {
+  if (ip.startsWith("::ffff:")) {
+    return ip.slice(7);
+  }
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(ip)) {
+    return ip;
+  }
+  return null;
+}
+function isIpv4InCidr(ip, cidr) {
+  const [cidrIp, prefixStr] = cidr.split("/");
+  if (!cidrIp || !prefixStr) return false;
+  const prefix = parseInt(prefixStr, 10);
+  if (isNaN(prefix) || prefix < 0 || prefix > 32) return false;
+  const ipNum = ipv4ToNum(ip);
+  const cidrNum = ipv4ToNum(cidrIp);
+  if (ipNum === null || cidrNum === null) return false;
+  const mask = prefix === 0 ? 0 : -1 << 32 - prefix >>> 0;
+  return (ipNum & mask) === (cidrNum & mask);
+}
+function ipv4ToNum(ip) {
+  const parts = ip.split(".");
+  if (parts.length !== 4) return null;
+  let num = 0;
+  for (const part of parts) {
+    const n = parseInt(part, 10);
+    if (isNaN(n) || n < 0 || n > 255) return null;
+    num = num << 8 | n;
+  }
+  return num >>> 0;
+}
+function isIpv6InCidr(ip, cidr) {
+  const [cidrIp, prefixStr] = cidr.split("/");
+  if (!cidrIp || !prefixStr) return false;
+  const prefix = parseInt(prefixStr, 10);
+  if (isNaN(prefix)) return false;
+  const ipBytes = expandIpv6(ip);
+  const cidrBytes = expandIpv6(cidrIp);
+  if (!ipBytes || !cidrBytes) return false;
+  const fullBytes = Math.floor(prefix / 8);
+  for (let i = 0; i < fullBytes && i < 16; i++) {
+    if (ipBytes[i] !== cidrBytes[i]) return false;
+  }
+  const remainingBits = prefix % 8;
+  if (remainingBits > 0 && fullBytes < 16) {
+    const mask = -1 << 8 - remainingBits & 255;
+    if ((ipBytes[fullBytes] & mask) !== (cidrBytes[fullBytes] & mask)) return false;
+  }
+  return true;
+}
+function expandIpv6(ip) {
+  const zoneIdx = ip.indexOf("%");
+  if (zoneIdx !== -1) ip = ip.slice(0, zoneIdx);
+  const parts = ip.split("::");
+  if (parts.length > 2) return null;
+  const bytes = new Array(16).fill(0);
+  const expandGroup = (group) => {
+    if (!group) return [];
+    return group.split(":").flatMap((hex) => {
+      const val = parseInt(hex || "0", 16);
+      return [val >> 8 & 255, val & 255];
+    });
+  };
+  if (parts.length === 1) {
+    const expanded = expandGroup(parts[0]);
+    if (expanded.length !== 16) return null;
+    return expanded;
+  }
+  const left = expandGroup(parts[0]);
+  const right = expandGroup(parts[1]);
+  if (left.length + right.length > 16) return null;
+  for (let i = 0; i < left.length; i++) bytes[i] = left[i];
+  for (let i = 0; i < right.length; i++) bytes[16 - right.length + i] = right[i];
+  return bytes;
+}
+function createContextRunner() {
+  const storage = new async_hooks.AsyncLocalStorage();
+  return {
+    runWith(ctx, fn) {
+      return storage.run(ctx, fn);
+    },
+    getContext() {
+      const ctx = storage.getStore();
+      if (ctx === void 0) {
+        throw new Error("Extension context not set; invoke only through the extension adapter.");
+      }
+      return ctx;
+    }
+  };
+}
+function unwrapArgsForHandler(spec, args) {
+  if (args == null || typeof args !== "object" || Array.isArray(args)) return args;
+  const s = spec.inputSchema;
+  if (s?.type !== "object" || !s.properties || typeof s.properties !== "object") return args;
+  const props = s.properties;
+  const argsProp = props.args;
+  if (argsProp != null && typeof argsProp === "object" && argsProp.type === "object" && argsProp.properties != null) {
+    const obj = args;
+    if (Object.keys(obj).length === 1 && "args" in obj && typeof obj.args === "object" && obj.args !== null) {
+      return obj.args;
+    }
+  }
+  return args;
+}
+function createDynamicImportAdapter(options) {
+  const { kind, packageRoot, getExtensionContext, contextRunner } = options;
+  return {
+    kind,
+    async invoke(spec, args, execCtx) {
+      const meta = spec._meta;
+      const sourcePath = meta?.sourcePath;
+      const exportName = meta?.exportName;
+      if (!sourcePath || !exportName) {
+        throw new Error(`Extension tool ${spec.name} missing _meta.sourcePath or _meta.exportName`);
+      }
+      const defaultArgs = meta?.defaultArgs ?? {};
+      const mergedArgs = Object.keys(defaultArgs).length === 0 ? args : { ...defaultArgs, ...args };
+      const handlerArgs = unwrapArgsForHandler(spec, mergedArgs);
+      const resolvedPackageRoot = meta?.packageRoot ?? packageRoot;
+      const modulePath = path4__default.default.join(resolvedPackageRoot, `${sourcePath}.js`);
+      const mod = await import(url.pathToFileURL(modulePath).href);
+      const handler = mod[exportName];
+      if (typeof handler !== "function") {
+        throw new Error(
+          `Extension tool ${spec.name}: export "${exportName}" from ${sourcePath} is not a function`
+        );
+      }
+      const ctx = getExtensionContext(execCtx, spec, mergedArgs);
+      const output = await contextRunner.runWith(ctx, () => handler(handlerArgs));
+      return {
+        result: { result: output.result, evidence: output.evidence },
+        raw: { evidence: output.evidence }
+      };
+    }
+  };
+}
+function resolveExtensionPackageRoot(metaUrlOrPath) {
+  const dir = metaUrlOrPath.startsWith("file:") ? path4__default.default.dirname(url.fileURLToPath(metaUrlOrPath)) : path4__default.default.resolve(metaUrlOrPath);
+  const dist = path4__default.default.join(dir, "dist");
+  return fs.existsSync(dist) ? dist : dir;
+}
+
+// src/api/extension/registerExtension.ts
+function deriveConfigPrefixCandidates(prefixWithVersion) {
+  if (!prefixWithVersion) return [];
+  const candidates = /* @__PURE__ */ new Set([prefixWithVersion]);
+  if (prefixWithVersion.startsWith("npm.")) {
+    const versionless = prefixWithVersion.replace(/(?:\.\d+)+$/, "");
+    if (versionless && versionless !== prefixWithVersion) {
+      candidates.add(versionless);
+    }
+  }
+  return [...candidates];
+}
+function registerExtension(registry, options) {
+  const { packagePath, kind: kindOpt, config, getContextRunner, only, namePrefixes } = options;
+  const packageRoot = resolveExtensionPackageRoot(packagePath);
+  const contextRunner = getContextRunner();
+  const loaded = chunkBNIE2IKZ_cjs.loadExtensionManifest(packagePath);
+  const kind = kindOpt ?? loaded.kind ?? "extension";
+  chunkBNIE2IKZ_cjs.registerToolsFromManifest(registry, {
+    manifestPathOrDir: packagePath,
+    kind,
+    only,
+    namePrefixes,
+    packageRoot
+  });
+  const adapter = createDynamicImportAdapter({
+    kind,
+    packageRoot,
+    getExtensionContext: (execCtx, spec, mergedArgs) => {
+      const defaultArgs = spec._meta?.defaultArgs ?? {};
+      const baseConfig = config !== void 0 ? config : {};
+      const toolOverrides = baseConfig?.toolOverrides;
+      const shortName = spec._meta?.shortName ?? spec.name;
+      const prefixWithVersion = shortName && spec.name.endsWith(shortName) && spec.name.length > shortName.length ? spec.name.slice(0, spec.name.length - shortName.length - 1) : "";
+      const prefixCandidates = deriveConfigPrefixCandidates(prefixWithVersion);
+      const packageScopedKeys = prefixCandidates.map((prefix) => `${prefix}::${shortName}`);
+      const perTool = toolOverrides?.[spec.name] ?? packageScopedKeys.map((key) => toolOverrides?.[key]).find((value) => value !== void 0) ?? toolOverrides?.[shortName] ?? {};
+      const packageDefaults = baseConfig?.packageDefaults;
+      const packageDefaultsForPkg = prefixCandidates.map((prefix) => packageDefaults?.[prefix]).find((value) => value !== void 0) ?? {};
+      const baseWithoutOverrides = { ...baseConfig };
+      delete baseWithoutOverrides.toolOverrides;
+      delete baseWithoutOverrides.packageDefaults;
+      const resolvedConfig = {
+        ...defaultArgs,
+        ...baseWithoutOverrides,
+        ...packageDefaultsForPkg,
+        ...perTool,
+        ...mergedArgs ?? {}
+      };
+      return { execCtx, config: resolvedConfig };
+    },
+    contextRunner: {
+      runWith(ctx, fn) {
+        return contextRunner.runWith(ctx, fn);
+      }
+    }
+  });
+  return adapter;
+}
+
+// src/api/extension/createExtension.ts
+function resolvePackagePath(options) {
+  if (options.packagePath != null && options.packagePath !== "") return options.packagePath;
+  if (options.importMeta?.url) return path4__default.default.dirname(url.fileURLToPath(options.importMeta.url));
+  throw new Error("createExtension: provide packagePath or importMeta");
+}
+function createExtension(options) {
+  const packagePath = resolvePackagePath(options);
+  const kind = options.kind;
+  const buildConfig = "buildConfig" in options ? options.buildConfig : void 0;
+  const contextRunner = createContextRunner();
+  return {
+    register(registry, userConfigOrOpts, opts) {
+      const config = buildConfig ? buildConfig(userConfigOrOpts) : userConfigOrOpts;
+      return registerExtension(registry, {
+        packagePath,
+        kind,
+        config,
+        getContextRunner: () => contextRunner,
+        only: opts?.only ?? userConfigOrOpts?.only,
+        namePrefixes: opts?.namePrefixes ?? userConfigOrOpts?.namePrefixes
+      });
+    },
+    getContext() {
+      return contextRunner.getContext();
+    },
+    runWith(ctx, fn) {
+      return contextRunner.runWith(ctx, fn);
+    }
+  };
+}
+function copyToolYamlRecursive(srcDir, destDir) {
+  if (!fs.existsSync(srcDir)) return 0;
+  let copied = 0;
+  for (const e of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    const srcPath = path4__default.default.join(srcDir, e.name);
+    const destPath = path4__default.default.join(destDir, e.name);
+    if (e.isFile() && (e.name.endsWith(".tool.yaml") || e.name.endsWith(".example.yaml"))) {
+      if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
+      fs.copyFileSync(srcPath, destPath);
+      copied++;
+    } else if (e.isDirectory()) {
+      copied += copyToolYamlRecursive(srcPath, destPath);
+    }
+  }
+  return copied;
+}
+function generateExtensionManifest(projectRoot = process.cwd(), options = {}) {
+  const root = path4__default.default.resolve(projectRoot);
+  const outDir = path4__default.default.resolve(options.outDir ?? path4__default.default.join(root, "dist"));
+  const kind = options.kind ?? "core";
+  const { specs, errors } = chunkJW4EMVTE_cjs.scanForTools({
+    projectPath: root,
+    include: options.include ?? ["**/*.ts"],
+    tsconfigPath: options.tsconfigPath
+  });
+  if (errors.length > 0) {
+    console.warn("generateExtensionManifest: scan errors", errors);
+  }
+  const entries = specs.map((spec) => {
+    const sourcePathNoExt = (spec.sourcePath ?? "").replace(/\.(ts|tsx)$/i, "");
+    const pathBasedName = sourcePathNoExt.replace(/^src\//, "").replace(/\//g, ".");
+    const name = spec.exportName ?? pathBasedName;
+    const sideEffect = spec._meta?.hitl?.sideEffect ?? "none";
+    return {
+      name,
+      description: spec.description ?? sourcePathNoExt,
+      inputSchema: spec.inputSchema ?? { type: "object", additionalProperties: true },
+      outputSchema: spec.outputSchema ?? { type: "object", additionalProperties: true },
+      sourcePath: sourcePathNoExt,
+      exportName: spec.exportName ?? "",
+      sideEffect
+    };
+  });
+  if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+  const manifestPath = path4__default.default.join(outDir, "core-tools-manifest.json");
+  fs.writeFileSync(
+    manifestPath,
+    JSON.stringify({ kind, tools: entries }, null, 2),
+    "utf-8"
+  );
+  let toolYamlCopied = 0;
+  const copyDirs = options.copyToolYamlDirs;
+  if (copyDirs?.length) {
+    for (const d of copyDirs) {
+      const srcDir = path4__default.default.join(root, d);
+      const destDir = path4__default.default.join(outDir, d);
+      try {
+        toolYamlCopied += copyToolYamlRecursive(srcDir, destDir);
+      } catch {
+      }
+    }
+  }
+  return { manifestPath, toolsCount: entries.length, toolYamlCopied };
+}
+function generateManifest(projectRoot = process.cwd(), options = {}) {
+  const { manifestPath, toolsCount, toolYamlCopied } = generateExtensionManifest(projectRoot, {
+    include: ["src/**/*.ts"],
+    copyToolYamlDirs: ["src"],
+    ...options
+  });
+  console.log(`Wrote ${toolsCount} tools to ${path4__default.default.relative(projectRoot, manifestPath)}`);
+  if (toolYamlCopied > 0) console.log(`Copied ${toolYamlCopied} .tool.yaml/.example.yaml file(s) to dist`);
+}
+
+// src/utils/overrideWithConfig.ts
+function overrideWithConfig(defaults, config) {
+  const source = config != null && typeof config === "object" && !Array.isArray(config) ? config : {};
+  const output = { ...defaults };
+  for (const key of Object.keys(defaults)) {
+    if (key in source && source[key] !== void 0) {
+      output[key] = source[key];
+    }
+  }
+  return output;
+}
+
+// src/api/extension/support/groupPrefix.ts
+function getGroupNamePrefixes(options) {
+  const { groups, only, groupPrefixMap } = options;
+  const onlySet = only?.length ? new Set(only) : null;
+  const namePrefixes = !onlySet && groups?.length ? groups.map((g) => groupPrefixMap[g]).filter((x) => x != null) : void 0;
+  return {
+    ...onlySet ? { only: Array.from(onlySet) } : {},
+    ...namePrefixes?.length ? { namePrefixes } : {}
+  };
+}
+
+Object.defineProperty(exports, "loadExtensionManifest", {
+  enumerable: true,
+  get: function () { return chunkBNIE2IKZ_cjs.loadExtensionManifest; }
+});
+Object.defineProperty(exports, "loadToolYaml", {
+  enumerable: true,
+  get: function () { return chunkBNIE2IKZ_cjs.loadToolYaml; }
+});
+Object.defineProperty(exports, "registerToolsFromManifest", {
+  enumerable: true,
+  get: function () { return chunkBNIE2IKZ_cjs.registerToolsFromManifest; }
+});
+Object.defineProperty(exports, "ToolRegistry", {
+  enumerable: true,
+  get: function () { return chunkAGLGFQUW_cjs.ToolRegistry; }
+});
+Object.defineProperty(exports, "createTaggedError", {
+  enumerable: true,
+  get: function () { return chunkAGLGFQUW_cjs.createTaggedError; }
+});
+Object.defineProperty(exports, "isRetryable", {
+  enumerable: true,
+  get: function () { return chunkAGLGFQUW_cjs.isRetryable; }
+});
+Object.defineProperty(exports, "resolveSandboxedPath", {
+  enumerable: true,
+  get: function () { return chunkAGLGFQUW_cjs.resolveSandboxedPath; }
+});
+Object.defineProperty(exports, "setSandboxValidationEnabled", {
+  enumerable: true,
+  get: function () { return chunkAGLGFQUW_cjs.setSandboxValidationEnabled; }
+});
+Object.defineProperty(exports, "withRetry", {
+  enumerable: true,
+  get: function () { return chunkAGLGFQUW_cjs.withRetry; }
+});
+exports.createContextRunner = createContextRunner;
+exports.createDynamicImportAdapter = createDynamicImportAdapter;
+exports.createExtension = createExtension;
+exports.generateExtensionManifest = generateExtensionManifest;
+exports.generateManifest = generateManifest;
+exports.getGroupNamePrefixes = getGroupNamePrefixes;
+exports.isIpInBlockedCidrs = isIpInBlockedCidrs;
+exports.overrideWithConfig = overrideWithConfig;
+exports.registerExtension = registerExtension;
+exports.resolveExtensionPackageRoot = resolveExtensionPackageRoot;
+exports.validateUrl = validateUrl;
+//# sourceMappingURL=sdk.cjs.map
+//# sourceMappingURL=sdk.cjs.map