@graphrefly/ts 0.0.1 → 0.0.2

package/dist/executors/tool-provider-adapters.cjs

@@ -0,0 +1,3091 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/executors/tool-provider-adapters.ts
+var tool_provider_adapters_exports = {};
+__export(tool_provider_adapters_exports, {
+  httpToolProviderCatalog: () => httpToolProviderCatalog,
+  httpToolProviderRuntime: () => httpToolProviderRuntime,
+  localBuiltinToolProviderAdapterPack: () => localBuiltinToolProviderAdapterPack,
+  localBuiltinToolProviderBinding: () => localBuiltinToolProviderBinding,
+  processToolProviderAdapterPack: () => processToolProviderAdapterPack,
+  processToolProviderBinding: () => processToolProviderBinding,
+  processToolProviderCatalog: () => processToolProviderCatalog
+});
+module.exports = __toCommonJS(tool_provider_adapters_exports);
+var import_node_child_process = require("child_process");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+
+// src/protocol/messages.ts
+var SENTINEL = void 0;
+
+// src/ctx/types.ts
+function depWaves(ctx, depIndex) {
+  return ctx.waveData[depIndex] ?? [];
+}
+function depBatch(ctx, depIndex) {
+  const waves = depWaves(ctx, depIndex);
+  if (waves.length === 0) return null;
+  const flattened = waves.flat().filter((v) => v !== SENTINEL);
+  return flattened.length === 0 ? [] : flattened;
+}
+
+// src/orchestration/agent-runtime-common.ts
+function uniqueSourceRefs(sourceRefs) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const sourceRef of sourceRefs) {
+    const key = `${sourceRef.kind}:${sourceRef.id}:${JSON.stringify(sourceRef.metadata ?? {})}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(sourceRef);
+  }
+  return Object.freeze(unique);
+}
+function stableJsonStringify(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(value, (_key, child) => {
+    if (typeof child === "bigint") return child.toString();
+    if (typeof child === "function") return "[Function]";
+    if (!isRecord(child) && !Array.isArray(child)) return child;
+    if (seen.has(child)) return "[Circular]";
+    seen.add(child);
+    if (Array.isArray(child)) return child;
+    return Object.keys(child).sort().reduce((out, key) => {
+      out[key] = child[key];
+      return out;
+    }, {});
+  });
+}
+function stableStringHash(value) {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i += 1) {
+    hash ^= value.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36);
+}
+function cloneGraphVisibleMaterial(value) {
+  if (!isRecord(value) && !Array.isArray(value)) return value;
+  if (Array.isArray(value))
+    return Object.freeze(value.map((item) => cloneGraphVisibleMaterial(item)));
+  return Object.freeze(
+    Object.entries(value).reduce((record, [key, child]) => {
+      record[key] = cloneGraphVisibleMaterial(child);
+      return record;
+    }, {})
+  );
+}
+function projectRuntimeFact(graph, runtime, name, factory, pick) {
+  return graph.node(
+    [runtime],
+    (ctx) => {
+      for (const fact of depBatch(ctx, 0) ?? []) {
+        const typed = fact;
+        const value = pick(typed);
+        if (value !== void 0) ctx.down([["DATA", value]]);
+      }
+    },
+    { name, factory }
+  );
+}
+function forEachDepBatch(ctx, start, count, fn) {
+  for (let i = 0; i < count; i += 1) {
+    for (const value of depBatch(ctx, start + i) ?? []) fn(value);
+  }
+}
+function forbiddenDataKeys(value, path = [], seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value === "function") return [{ path, reason: "function-value" }];
+  if (typeof value === "symbol" || typeof value === "bigint") {
+    return [{ path, reason: "non-graph-visible-primitive" }];
+  }
+  if (!isRecord(value) && !Array.isArray(value)) return [];
+  if (typeof value === "object" && value !== null) {
+    if (seen.has(value)) return [];
+    seen.add(value);
+  }
+  const issues = [];
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => {
+      issues.push(...forbiddenDataKeys(item, [...path, index], seen));
+    });
+    return issues;
+  }
+  if (!isPlainRecord(value)) return [{ path, reason: "non-plain-runtime-object" }];
+  const symbolKeys = Object.getOwnPropertySymbols(value);
+  if (symbolKeys.length > 0) {
+    issues.push({ path, reason: "symbol-key" });
+  }
+  for (const [key, child] of Object.entries(value)) {
+    const nextPath = [...path, key];
+    if (/^(apiKey|api_key|secret|client|transport|subprocess|sdk|oauth|credential|credentials|accessToken|access_token|refreshToken|refresh_token|idToken|id_token|token|password|passphrase|authorization|authHeader|auth_header|bearer|privateKey|private_key|sessionCookie|session_cookie|cookie)$/i.test(
+      key
+    )) {
+      issues.push({ path: nextPath, reason: "forbidden-runtime-key" });
+    }
+    issues.push(...forbiddenDataKeys(child, nextPath, seen));
+  }
+  return issues;
+}
+function forbiddenGraphVisibleMaterialIssues(value, subjectRef, area) {
+  if (value === void 0) return [];
+  const forbidden = publicMaterialForbiddenKeys(value, "provider");
+  if (forbidden.length === 0) return [];
+  return Object.freeze(
+    forbidden.map(
+      (entry) => dataIssue(
+        "tool-provider-catalog-forbidden-runtime-material",
+        "Tool provider catalog material must not contain runtime-private adapter material.",
+        { subjectId: subjectRef.id, refs: [subjectRef], details: { area, reason: entry.reason } }
+      )
+    )
+  );
+}
+function sanitizeAdapterInputSourceRefs(sourceRefs) {
+  return canonicalPublicSourceRefs(sourceRefs);
+}
+function sanitizeGraphVisibleRecord(value, policy) {
+  return sanitizePublicRecord(value, { mode: "graph", policy });
+}
+function sanitizeProviderGraphVisibleRecord(value, policy) {
+  return sanitizePublicRecord(value, { mode: "provider", policy });
+}
+function canonicalPublicSourceRefs(sourceRefs) {
+  return uniqueSourceRefs(
+    sourceRefs.map((sourceRef) => {
+      const metadata = sanitizePublicRecord(sourceRef.metadata, { mode: "provider" });
+      return metadata === void 0 ? { kind: sourceRef.kind, id: sourceRef.id } : { kind: sourceRef.kind, id: sourceRef.id, metadata };
+    })
+  );
+}
+function sanitizePublicRecord(value, opts) {
+  if (value === void 0 || publicMaterialForbiddenKeys(value, opts.mode).length > 0) {
+    return void 0;
+  }
+  return Object.freeze(boundRecordStrings(value, maxPublicMetadataStringChars(opts.policy)));
+}
+function publicMaterialForbiddenKeys(value, mode) {
+  const forbidden = [...forbiddenDataKeys(value)];
+  if (mode === "provider") forbidden.push(...forbiddenProviderRawMaterialKeys(value));
+  return forbidden;
+}
+function unlockedToolProviderPolicyOverrides(overrides) {
+  if (overrides === void 0) return void 0;
+  const rest = { ...overrides };
+  delete rest.kind;
+  delete rest.policyId;
+  delete rest.providerId;
+  return rest;
+}
+function sanitizeAgentOutputEnvelope(envelope, input, policy, issues) {
+  const summary = envelope.summary === void 0 ? void 0 : boundedPublicText(envelope.summary, "summary", input, policy, issues);
+  const metadata = sanitizeRuntimeMetadata(envelope.metadata, input, policy, issues);
+  if (metadata === void 0 && envelope.metadata !== void 0) {
+    issues.push(
+      dataIssue(
+        "tool-provider-adapter-runtime-metadata-redacted",
+        "Tool provider adapter runtime metadata was omitted because it contained runtime-private material.",
+        {
+          subjectId: input.requestId,
+          refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+          severity: "warning"
+        }
+      )
+    );
+  }
+  const value = sanitizeInlineOutputValue(envelope.value, input, policy, issues);
+  return Object.freeze({
+    kind: envelope.kind,
+    value,
+    refs: envelope.refs === void 0 ? void 0 : sanitizeAdapterInputSourceRefs(envelope.refs),
+    summary,
+    artifacts: envelope.artifacts === void 0 ? void 0 : Object.freeze(
+      envelope.artifacts.map(
+        (artifact) => sanitizeExecutorArtifactMaterial(artifact, input, policy, issues)
+      )
+    ),
+    metadata
+  });
+}
+function sanitizeExecutorArtifactMaterial(artifact, input, policy, issues) {
+  const metadata = sanitizeRuntimeMetadata(artifact.metadata, input, policy, issues);
+  const redaction = sanitizeRuntimeMetadata(artifact.redaction, input, policy, issues);
+  return Object.freeze({
+    kind: artifact.kind,
+    ...artifact.format === void 0 ? {} : { format: artifact.format },
+    ...artifact.schemaRef === void 0 ? {} : { schemaRef: artifact.schemaRef },
+    ...artifact.schemaKind === void 0 ? {} : { schemaKind: artifact.schemaKind },
+    ...artifact.mimeType === void 0 ? {} : { mimeType: artifact.mimeType },
+    ...artifact.mediaType === void 0 ? {} : { mediaType: artifact.mediaType },
+    ...artifact.filename === void 0 ? {} : { filename: artifact.filename },
+    ...artifact.byteLength === void 0 ? {} : { byteLength: artifact.byteLength },
+    ...artifact.digest === void 0 ? {} : { digest: artifact.digest },
+    ...artifact.encoding === void 0 ? {} : { encoding: artifact.encoding },
+    dataMode: artifact.dataMode,
+    ...artifact.summary === void 0 ? {} : { summary: boundedPublicText(artifact.summary, "summary", input, policy, issues) },
+    ...artifact.value === void 0 ? {} : { value: sanitizeInlineOutputValue(artifact.value, input, policy, issues) },
+    ...artifact.ref === void 0 ? {} : { ref: sanitizeAdapterInputSourceRefs([artifact.ref])[0] },
+    ...artifact.refs === void 0 ? {} : { refs: sanitizeAdapterInputSourceRefs(artifact.refs) },
+    ...artifact.sourceRefs === void 0 ? {} : { sourceRefs: sanitizeAdapterInputSourceRefs(artifact.sourceRefs) },
+    ...artifact.sizeEvidence === void 0 ? {} : {
+      sizeEvidence: Object.freeze(
+        artifact.sizeEvidence.map(
+          (evidence) => sanitizeSizeCapacityEvidence(evidence, input, policy, issues)
+        )
+      )
+    },
+    ...artifact.sensitivity === void 0 ? {} : { sensitivity: Object.freeze([...artifact.sensitivity]) },
+    ...redaction === void 0 ? {} : { redaction },
+    ...metadata === void 0 ? {} : { metadata }
+  });
+}
+function sanitizeSizeCapacityEvidence(evidence, input, policy, issues) {
+  const metadata = sanitizeRuntimeMetadata(evidence.metadata, input, policy, issues);
+  const redaction = sanitizeRuntimeMetadata(evidence.redaction, input, policy, issues);
+  return Object.freeze({
+    kind: "size-capacity-evidence",
+    unit: evidence.unit,
+    quantity: evidence.quantity,
+    measurementSource: evidence.measurementSource,
+    ...evidence.estimated === void 0 ? {} : { estimated: evidence.estimated },
+    ...evidence.encoding === void 0 ? {} : { encoding: evidence.encoding },
+    ...evidence.mediaType === void 0 ? {} : { mediaType: evidence.mediaType },
+    ...evidence.sourceRefs === void 0 ? {} : { sourceRefs: sanitizeAdapterInputSourceRefs(evidence.sourceRefs) },
+    ...evidence.refs === void 0 ? {} : { refs: sanitizeAdapterInputSourceRefs(evidence.refs) },
+    ...evidence.issues === void 0 ? {} : {
+      issues: Object.freeze(evidence.issues.map((issue2) => sanitizeAdapterInputIssue(issue2)))
+    },
+    ...evidence.sensitivity === void 0 ? {} : { sensitivity: Object.freeze([...evidence.sensitivity]) },
+    ...redaction === void 0 ? {} : { redaction },
+    ...metadata === void 0 ? {} : { metadata }
+  });
+}
+function sanitizeAgentNeed(need, input, policy, issues) {
+  const metadata = sanitizeRuntimeMetadata(need.metadata, input, policy, issues);
+  if (metadata === void 0 && need.metadata !== void 0) {
+    issues.push(
+      dataIssue(
+        "tool-provider-adapter-runtime-metadata-redacted",
+        "Tool provider adapter runtime metadata was omitted because it contained runtime-private material.",
+        {
+          subjectId: input.requestId,
+          refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+          severity: "warning"
+        }
+      )
+    );
+  }
+  return Object.freeze({
+    kind: need.kind,
+    message: need.message === void 0 ? void 0 : boundedPublicText(need.message, "message", input, policy, issues),
+    refs: need.refs === void 0 ? void 0 : sanitizeAdapterInputSourceRefs(need.refs),
+    metadata
+  });
+}
+function sanitizeRuntimeMetadata(value, input, policy, issues) {
+  if (value === void 0) return void 0;
+  const bounded = sanitizePublicRecordWithEvidence(value, { mode: "provider", policy });
+  if (bounded === void 0) return void 0;
+  for (const entry of bounded.truncated) {
+    issues.push(
+      dataIssue(
+        "tool-provider-adapter-runtime-public-text-truncated",
+        "Tool provider adapter runtime public text was truncated; large/raw material must use artifact summary/ref envelopes.",
+        {
+          subjectId: input.requestId,
+          refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+          severity: "warning",
+          details: {
+            field: "metadata",
+            path: entry.path.join("."),
+            originalChars: entry.originalChars,
+            limitChars: entry.limitChars,
+            unit: "chars",
+            measurementSource: "js-string-length"
+          }
+        }
+      )
+    );
+  }
+  return Object.freeze(bounded.value);
+}
+function sanitizePublicRecordWithEvidence(value, opts) {
+  if (publicMaterialForbiddenKeys(value, opts.mode).length > 0) return void 0;
+  return boundRecordStringsWithEvidence(value, maxPublicMetadataStringChars(opts.policy));
+}
+function sanitizeInlineOutputValue(value, input, policy, issues) {
+  if (value === void 0) return void 0;
+  const forbidden = [
+    ...publicMaterialForbiddenKeys(value, "provider"),
+    ...oversizedInlineTextKeys(value, maxPublicSummaryChars(policy))
+  ];
+  if (forbidden.length === 0) return cloneGraphVisibleMaterial(value);
+  for (const entry of forbidden) {
+    issues.push(
+      dataIssue(
+        "tool-provider-adapter-runtime-forbidden-runtime-material",
+        "Tool provider adapter runtime output value must not inline runtime-private, raw, or oversized provider material.",
+        {
+          subjectId: input.requestId,
+          refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+          details: { reason: entry.reason }
+        }
+      )
+    );
+  }
+  return void 0;
+}
+function boundedPublicText(text, field, input, policy, issues) {
+  const limit = field === "summary" ? maxPublicSummaryChars(policy) : field === "reason" ? maxPublicReasonChars(policy) : maxPublicMessageChars(policy);
+  const bounded = boundPublicText(text, limit);
+  if (!bounded.truncated) return bounded.text;
+  issues.push(
+    dataIssue(
+      "tool-provider-adapter-runtime-public-text-truncated",
+      "Tool provider adapter runtime public text was truncated; large/raw material must use artifact summary/ref envelopes.",
+      {
+        subjectId: input.requestId,
+        refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+        severity: "warning",
+        details: {
+          field,
+          originalChars: bounded.originalChars,
+          limitChars: bounded.limitChars,
+          unit: "chars",
+          measurementSource: "js-string-length"
+        }
+      }
+    )
+  );
+  return bounded.text;
+}
+function boundPublicText(text, limitChars) {
+  const limit = Math.max(0, limitChars);
+  if (text.length <= limit) {
+    return { text, truncated: false, originalChars: text.length, limitChars: limit };
+  }
+  const bounded = limit <= 1 ? text.slice(0, limit) : limit <= 3 ? text.slice(0, limit) : `${text.slice(0, limit - 3)}...`;
+  return { text: bounded, truncated: true, originalChars: text.length, limitChars: limit };
+}
+function boundRecordStrings(value, limitChars, seen = /* @__PURE__ */ new WeakSet()) {
+  if (seen.has(value)) return {};
+  seen.add(value);
+  return Object.entries(value).reduce((out, [key, child]) => {
+    if (typeof child === "string") {
+      out[key] = boundPublicText(child, limitChars).text;
+    } else if (Array.isArray(child)) {
+      out[key] = child.map(
+        (item) => typeof item === "string" ? boundPublicText(item, limitChars).text : isPlainRecord(item) ? boundRecordStrings(item, limitChars, seen) : item
+      );
+    } else if (isPlainRecord(child)) {
+      out[key] = boundRecordStrings(child, limitChars, seen);
+    } else {
+      out[key] = child;
+    }
+    return out;
+  }, {});
+}
+function boundRecordStringsWithEvidence(value, limitChars, path = [], seen = /* @__PURE__ */ new WeakSet()) {
+  if (seen.has(value)) return { value: {}, truncated: [] };
+  seen.add(value);
+  const truncated = [];
+  const out = Object.entries(value).reduce((record, [key, child]) => {
+    const childPath = [...path, key];
+    if (typeof child === "string") {
+      const bounded = boundPublicText(child, limitChars);
+      record[key] = bounded.text;
+      if (bounded.truncated) {
+        truncated.push({
+          path: childPath,
+          originalChars: bounded.originalChars,
+          limitChars: bounded.limitChars
+        });
+      }
+    } else if (Array.isArray(child)) {
+      record[key] = child.map((item, index) => {
+        const itemPath = [...childPath, index];
+        if (typeof item === "string") {
+          const bounded = boundPublicText(item, limitChars);
+          if (bounded.truncated) {
+            truncated.push({
+              path: itemPath,
+              originalChars: bounded.originalChars,
+              limitChars: bounded.limitChars
+            });
+          }
+          return bounded.text;
+        }
+        if (isPlainRecord(item)) {
+          const nested = boundRecordStringsWithEvidence(item, limitChars, itemPath, seen);
+          truncated.push(...nested.truncated);
+          return nested.value;
+        }
+        return item;
+      });
+    } else if (isPlainRecord(child)) {
+      const nested = boundRecordStringsWithEvidence(child, limitChars, childPath, seen);
+      record[key] = nested.value;
+      truncated.push(...nested.truncated);
+    } else {
+      record[key] = child;
+    }
+    return record;
+  }, {});
+  return { value: out, truncated };
+}
+function sanitizeIssueDetails(details, policy) {
+  if (details === void 0) return void 0;
+  if (publicMaterialForbiddenKeys(details, "provider").length > 0) {
+    return { redacted: true, reason: "forbidden-runtime-material" };
+  }
+  const bounded = boundUnknownStringsWithEvidence(details, maxPublicMetadataStringChars(policy));
+  if (bounded.truncated.length === 0) return bounded.value;
+  const detailsTruncated = {
+    detailsTruncated: true,
+    detailsTruncatedPaths: bounded.truncated.map((entry) => entry.path.join(".")),
+    measurementSource: "js-string-length"
+  };
+  if (isPlainRecord(bounded.value)) {
+    return Object.freeze({ ...bounded.value, ...detailsTruncated });
+  }
+  return Object.freeze({ value: bounded.value, ...detailsTruncated });
+}
+function boundUnknownStringsWithEvidence(value, limitChars, path = [], seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value === "string") {
+    const bounded = boundPublicText(value, limitChars);
+    return {
+      value: bounded.text,
+      truncated: bounded.truncated ? [{ path, originalChars: bounded.originalChars, limitChars: bounded.limitChars }] : []
+    };
+  }
+  if (!isRecord(value) && !Array.isArray(value)) return { value, truncated: [] };
+  if (typeof value === "object" && value !== null) {
+    if (seen.has(value)) return { value: Array.isArray(value) ? [] : {}, truncated: [] };
+    seen.add(value);
+  }
+  const truncated = [];
+  if (Array.isArray(value)) {
+    const out2 = value.map((item, index) => {
+      const bounded = boundUnknownStringsWithEvidence(item, limitChars, [...path, index], seen);
+      truncated.push(...bounded.truncated);
+      return bounded.value;
+    });
+    return { value: out2, truncated };
+  }
+  const out = Object.entries(value).reduce((record, [key, child]) => {
+    const bounded = boundUnknownStringsWithEvidence(child, limitChars, [...path, key], seen);
+    record[key] = bounded.value;
+    truncated.push(...bounded.truncated);
+    return record;
+  }, {});
+  return { value: out, truncated };
+}
+function oversizedInlineTextKeys(value, limitChars, path = [], seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value === "string") {
+    return value.length > Math.max(0, limitChars) ? [{ path, reason: "oversized-inline-text" }] : [];
+  }
+  if (!isRecord(value) && !Array.isArray(value)) return [];
+  if (typeof value === "object" && value !== null) {
+    if (seen.has(value)) return [];
+    seen.add(value);
+  }
+  const issues = [];
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => {
+      issues.push(...oversizedInlineTextKeys(item, limitChars, [...path, index], seen));
+    });
+    return issues;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    issues.push(...oversizedInlineTextKeys(child, limitChars, [...path, key], seen));
+  }
+  return issues;
+}
+function maxPublicMessageChars(policy) {
+  return normalizedPublicTextLimit(policy?.maxMessageChars, 512);
+}
+function maxPublicSummaryChars(policy) {
+  return normalizedPublicTextLimit(policy?.maxSummaryChars, 512);
+}
+function maxPublicReasonChars(policy) {
+  return normalizedPublicTextLimit(policy?.maxReasonChars, 512);
+}
+function maxPublicMetadataStringChars(policy) {
+  return normalizedPublicTextLimit(policy?.maxMetadataStringChars, 256);
+}
+function normalizedPublicTextLimit(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(0, Math.floor(value));
+}
+function sanitizeAdapterInputIssue(issue2, policy) {
+  const boundedMessage = boundPublicText(issue2.message, maxPublicMessageChars(policy));
+  const details = sanitizeIssueDetails(issue2.details, policy);
+  const metadata = sanitizeProviderGraphVisibleRecord(issue2.metadata, policy);
+  const refs = issue2.refs === void 0 ? void 0 : Object.freeze(issue2.refs.filter((entry) => typeof entry === "string"));
+  return Object.freeze({
+    kind: issue2.kind,
+    code: issue2.code,
+    ...issue2.source === void 0 ? {} : { source: issue2.source },
+    message: boundedMessage.text,
+    severity: issue2.severity,
+    subjectId: issue2.subjectId,
+    ...issue2.correlationId === void 0 ? {} : { correlationId: issue2.correlationId },
+    ...issue2.causationId === void 0 ? {} : { causationId: issue2.causationId },
+    ...issue2.path === void 0 ? {} : { path: Object.freeze([...issue2.path]) },
+    ...refs === void 0 || refs.length === 0 ? {} : { refs },
+    ...issue2.retryable === void 0 ? {} : { retryable: issue2.retryable },
+    details: boundedMessage.truncated || details !== issue2.details ? {
+      ...isRecord(details) ? details : {},
+      ...boundedMessage.truncated ? {
+        truncated: true,
+        originalChars: boundedMessage.originalChars,
+        limitChars: boundedMessage.limitChars,
+        measurementSource: "js-string-length"
+      } : {}
+    } : details,
+    ...metadata === void 0 ? {} : { metadata }
+  });
+}
+function forbiddenProviderRawMaterialKeys(value, path = [], seen = /* @__PURE__ */ new WeakSet()) {
+  if (!isRecord(value) && !Array.isArray(value)) return [];
+  if (typeof value === "object" && value !== null) {
+    if (seen.has(value)) return [];
+    seen.add(value);
+  }
+  const issues = [];
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => {
+      issues.push(...forbiddenProviderRawMaterialKeys(item, [...path, index], seen));
+    });
+    return issues;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    const nextPath = [...path, key];
+    if (/^(stdout|stderr|stack|stackTrace|stack_trace|providerRaw|provider_raw|rawResponse|raw_response|diff|patch|fileContents|file_contents|binary|media)$/i.test(
+      key
+    )) {
+      issues.push({ path: nextPath, reason: "raw-provider-material" });
+    }
+    issues.push(...forbiddenProviderRawMaterialKeys(child, nextPath, seen));
+  }
+  return issues;
+}
+function dataIssue(code, message, opts = {}) {
+  return {
+    kind: "issue",
+    code,
+    message,
+    severity: opts.severity ?? "error",
+    subjectId: opts.subjectId,
+    refs: opts.refs?.map((r) => `${r.kind}:${r.id}`),
+    details: opts.details
+  };
+}
+function ref(kind, id) {
+  return { kind, id };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPlainRecord(value) {
+  if (!isRecord(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+// src/orchestration/agent-runtime-adapter-run.ts
+function requestToolProviderAdapterRun(input, opts = {}) {
+  const attempt = opts.attempt ?? 1;
+  return Object.freeze({
+    kind: "tool-provider-adapter-run-requested",
+    runId: opts.runId ?? defaultToolProviderAdapterRunId(input.adapterInputId, attempt, input),
+    adapterInputId: input.adapterInputId,
+    requestId: input.requestId,
+    operationId: input.operationId,
+    routeId: input.routeId,
+    providerId: input.providerId,
+    executorId: input.executorId,
+    profileId: input.profileId,
+    attempt,
+    reason: sanitizeToolProviderAdapterRunReason(opts.reason, attempt),
+    retryOfOutcomeId: opts.retryOfOutcomeId,
+    policyRefs: sanitizeAdapterInputSourceRefs(opts.policyRefs ?? input.policyRefs ?? []),
+    sourceRefs: sanitizeAdapterInputSourceRefs([
+      ref("tool-provider-adapter-input", input.adapterInputId),
+      ...input.sourceRefs ?? [],
+      ...opts.sourceRefs ?? []
+    ]),
+    metadata: sanitizeProviderGraphVisibleRecord(opts.metadata),
+    requestedAtMs: opts.requestedAtMs
+  });
+}
+function toolProviderAdapterRunProjector(graph, opts) {
+  return toolProviderAdapterRunProjectorInternal(graph, opts);
+}
+function toolProviderAdapterRunProjectorInternal(graph, opts) {
+  const name = opts.name ?? "toolProviderAdapterRun";
+  const explicitRunDeps = opts.runRequests ?? [];
+  const autoRunReadyInputs = opts.autoRunReadyInputs ?? true;
+  const runtime = graph.node(
+    [opts.inputs, ...explicitRunDeps],
+    (ctx) => {
+      const state = ctx.state.get() ?? {
+        inputs: /* @__PURE__ */ new Map(),
+        emittedKeys: /* @__PURE__ */ new Set(),
+        statusKeys: /* @__PURE__ */ new Set(),
+        issueKeys: /* @__PURE__ */ new Set(),
+        auditSeq: 0
+      };
+      for (const raw of depBatch(ctx, 0) ?? []) {
+        const input = raw;
+        state.inputs.set(input.adapterInputId, input);
+        opts.privateRetentionHooks?.onAdapterInputKey?.({
+          adapterInputId: input.adapterInputId,
+          dropInput: () => {
+            state.inputs.delete(input.adapterInputId);
+          }
+        });
+        if (input.status !== "ready") continue;
+        if (autoRunReadyInputs) {
+          emitRunRequested(
+            ctx,
+            state,
+            requestToolProviderAdapterRun(input, {
+              requestedAtMs: opts.now?.()
+            }),
+            opts.privateRetentionHooks
+          );
+        } else if (explicitRunDeps.length === 0) {
+          emitRunIssue(
+            ctx,
+            state,
+            "tool-provider-adapter-run-request-missing",
+            "Ready tool provider adapter input has no visible run request.",
+            input.adapterInputId,
+            [ref("tool-provider-adapter-input", input.adapterInputId)],
+            opts.privateRetentionHooks
+          );
+          emitRunStatus(
+            ctx,
+            state,
+            {
+              kind: "tool-provider-adapter-run-status",
+              runId: defaultToolProviderAdapterRunId(input.adapterInputId, 1, input),
+              adapterInputId: input.adapterInputId,
+              requestId: input.requestId,
+              operationId: input.operationId,
+              status: "missing-request",
+              attempt: 1,
+              sourceRefs: [ref("tool-provider-adapter-input", input.adapterInputId)]
+            },
+            opts.privateRetentionHooks
+          );
+        }
+      }
+      forEachDepBatch(ctx, 1, explicitRunDeps.length, (raw) => {
+        if (!isToolProviderAdapterRunRequestedLike(raw)) {
+          const request2 = fallbackToolProviderAdapterRunRequest(raw, opts.publicText);
+          const issue2 = dataIssue(
+            "tool-provider-adapter-run-request-invalid-shape",
+            "Tool provider adapter run request must be a data object with runId, adapterInputId, requestId, operationId, and attempt.",
+            {
+              subjectId: request2.adapterInputId,
+              refs: [ref("tool-provider-adapter-run", request2.runId)]
+            }
+          );
+          emitRunIssueFact(ctx, state, issue2, opts.privateRetentionHooks);
+          emitRunStatus(
+            ctx,
+            state,
+            {
+              kind: "tool-provider-adapter-run-status",
+              runId: request2.runId,
+              adapterInputId: request2.adapterInputId,
+              requestId: request2.requestId,
+              operationId: request2.operationId,
+              status: "mismatched-request",
+              attempt: request2.attempt,
+              issues: [issue2],
+              sourceRefs: request2.sourceRefs
+            },
+            opts.privateRetentionHooks
+          );
+          emitRunAudit(ctx, state, "tool-provider-adapter-run-request-invalid-shape", request2, {
+            issueCode: issue2.code
+          });
+          return;
+        }
+        const request = raw;
+        const input = state.inputs.get(request.adapterInputId);
+        if (input === void 0) {
+          const replayClassification = opts.privateRetentionHooks?.classifyRetainedRunRequestReplayEvidence?.(request);
+          if (replayClassification?.kind === "retention-gap") {
+            emitRunRequested(
+              ctx,
+              state,
+              sanitizeRetainedToolProviderAdapterRunRequest(request, opts.publicText),
+              opts.privateRetentionHooks
+            );
+            return;
+          }
+          const issue2 = dataIssue(
+            "tool-provider-adapter-run-request-missing-input",
+            "Tool provider adapter run request references an unknown adapter input.",
+            {
+              subjectId: request.adapterInputId,
+              refs: sanitizeAdapterInputSourceRefs([
+                ref("tool-provider-adapter-run", request.runId),
+                ...request.sourceRefs ?? []
+              ])
+            }
+          );
+          emitRunIssueFact(ctx, state, issue2, opts.privateRetentionHooks);
+          emitRunStatus(
+            ctx,
+            state,
+            {
+              kind: "tool-provider-adapter-run-status",
+              runId: request.runId,
+              adapterInputId: request.adapterInputId,
+              requestId: request.requestId,
+              operationId: request.operationId,
+              status: "missing-input",
+              attempt: request.attempt,
+              issues: [issue2],
+              sourceRefs: sanitizeAdapterInputSourceRefs(request.sourceRefs ?? [])
+            },
+            opts.privateRetentionHooks
+          );
+          return;
+        }
+        const issues = runRequestIdentityIssues(request, input);
+        if (input.status !== "ready") {
+          issues.push(
+            dataIssue(
+              "tool-provider-adapter-run-request-input-not-ready",
+              "Tool provider adapter run request requires a ready adapter input.",
+              {
+                subjectId: input.requestId,
+                refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+                details: { status: input.status }
+              }
+            )
+          );
+        }
+        if (issues.length > 0) {
+          for (const issue2 of issues)
+            emitRunIssueFact(ctx, state, issue2, opts.privateRetentionHooks);
+          emitRunStatus(
+            ctx,
+            state,
+            {
+              kind: "tool-provider-adapter-run-status",
+              runId: request.runId,
+              adapterInputId: request.adapterInputId,
+              requestId: request.requestId,
+              operationId: request.operationId,
+              status: "mismatched-request",
+              attempt: request.attempt,
+              issues: Object.freeze(issues),
+              sourceRefs: sanitizeAdapterInputSourceRefs(request.sourceRefs ?? [])
+            },
+            opts.privateRetentionHooks
+          );
+          emitRunAudit(ctx, state, "tool-provider-adapter-run-request-rejected", request, {
+            issueCodes: issues.map((issue2) => issue2.code)
+          });
+          return;
+        }
+        emitRunRequested(
+          ctx,
+          state,
+          sanitizeToolProviderAdapterRunRequest(request, input, opts.publicText),
+          opts.privateRetentionHooks
+        );
+      });
+      ctx.state.set(state);
+    },
+    { name: `${name}/runtime`, factory: "toolProviderAdapterRunProjector", partial: true }
+  );
+  return {
+    requests: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/requests`,
+      "toolProviderAdapterRunRequests",
+      (fact) => fact.kind === "request" ? fact.request : void 0
+    ),
+    status: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/status`,
+      "toolProviderAdapterRunStatus",
+      (fact) => fact.kind === "status" ? fact.status : void 0
+    ),
+    issues: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/issues`,
+      "toolProviderAdapterRunIssues",
+      (fact) => fact.kind === "issue" ? fact.issue : void 0
+    ),
+    audit: projectRuntimeFact(
+      graph,
+      runtime,
+      `${name}/audit`,
+      "toolProviderAdapterRunAudit",
+      (fact) => fact.kind === "audit" ? fact.audit : void 0
+    )
+  };
+}
+function defaultToolProviderAdapterRunId(adapterInputId, attempt, input) {
+  const suffix = input === void 0 ? "" : `:${stableStringHash(stableJsonStringify(input))}`;
+  return `${adapterInputId}:run-${attempt}${suffix}`;
+}
+function sanitizeToolProviderAdapterRunReason(reason, attempt, policy) {
+  const value = reason ?? (attempt === 1 ? "initial" : "retry");
+  return boundPublicText(value, maxPublicReasonChars(policy)).text;
+}
+function sanitizeToolProviderAdapterRunRequest(request, input, policy) {
+  return Object.freeze({
+    ...request,
+    reason: sanitizeToolProviderAdapterRunReason(request.reason, request.attempt, policy),
+    policyRefs: sanitizeAdapterInputSourceRefs(request.policyRefs ?? input.policyRefs ?? []),
+    sourceRefs: sanitizeAdapterInputSourceRefs([
+      ref("tool-provider-adapter-input", input.adapterInputId),
+      ...input.sourceRefs ?? [],
+      ...request.sourceRefs ?? []
+    ]),
+    metadata: sanitizeProviderGraphVisibleRecord(request.metadata)
+  });
+}
+function sanitizeRetainedToolProviderAdapterRunRequest(request, policy) {
+  const policyRefs = sanitizeAdapterInputSourceRefs(request.policyRefs ?? []);
+  const sourceRefs = sanitizeAdapterInputSourceRefs(request.sourceRefs ?? []);
+  const metadata = sanitizeProviderGraphVisibleRecord(request.metadata);
+  return Object.freeze({
+    kind: "tool-provider-adapter-run-requested",
+    runId: request.runId,
+    adapterInputId: request.adapterInputId,
+    requestId: request.requestId,
+    operationId: request.operationId,
+    ...request.routeId === void 0 ? {} : { routeId: request.routeId },
+    ...request.providerId === void 0 ? {} : { providerId: request.providerId },
+    ...request.executorId === void 0 ? {} : { executorId: request.executorId },
+    ...request.profileId === void 0 ? {} : { profileId: request.profileId },
+    attempt: request.attempt,
+    reason: sanitizeToolProviderAdapterRunReason(request.reason, request.attempt, policy),
+    ...request.retryOfOutcomeId === void 0 ? {} : { retryOfOutcomeId: request.retryOfOutcomeId },
+    ...policyRefs.length === 0 ? {} : { policyRefs },
+    ...sourceRefs.length === 0 ? {} : { sourceRefs },
+    ...metadata === void 0 ? {} : { metadata },
+    ...request.requestedAtMs === void 0 ? {} : { requestedAtMs: request.requestedAtMs }
+  });
+}
+function isToolProviderAdapterRunRequestedLike(value) {
+  const attempt = isRecord(value) ? value.attempt : void 0;
+  return isRecord(value) && value.kind === "tool-provider-adapter-run-requested" && typeof value.runId === "string" && value.runId.length > 0 && typeof value.adapterInputId === "string" && value.adapterInputId.length > 0 && typeof value.requestId === "string" && value.requestId.length > 0 && typeof value.operationId === "string" && value.operationId.length > 0 && typeof attempt === "number" && Number.isInteger(attempt) && attempt > 0 && typeof value.reason === "string" && value.reason.length > 0;
+}
+function fallbackToolProviderAdapterRunRequest(raw, policy) {
+  const record = isRecord(raw) ? raw : {};
+  const adapterInputId = typeof record.adapterInputId === "string" && record.adapterInputId.length > 0 ? record.adapterInputId : "<invalid-adapter-input>";
+  const runId = typeof record.runId === "string" && record.runId.length > 0 ? record.runId : `${adapterInputId}:invalid-run`;
+  const attempt = typeof record.attempt === "number" && Number.isInteger(record.attempt) && record.attempt > 0 ? record.attempt : 1;
+  const metadata = isRecord(record.metadata) ? sanitizeProviderGraphVisibleRecord(record.metadata, policy) : void 0;
+  return Object.freeze({
+    kind: "tool-provider-adapter-run-requested",
+    runId,
+    adapterInputId,
+    requestId: typeof record.requestId === "string" && record.requestId.length > 0 ? record.requestId : "<invalid-request>",
+    operationId: typeof record.operationId === "string" && record.operationId.length > 0 ? record.operationId : "<invalid-operation>",
+    attempt,
+    reason: sanitizeToolProviderAdapterRunReason(
+      typeof record.reason === "string" && record.reason.length > 0 ? record.reason : "manual",
+      attempt,
+      policy
+    ),
+    sourceRefs: sanitizeAdapterInputSourceRefs([
+      ref("tool-provider-adapter-run", runId),
+      ...sanitizeUntrustedSourceRefs(record.sourceRefs)
+    ]),
+    ...metadata === void 0 ? {} : { metadata }
+  });
+}
+function sanitizeUntrustedSourceRefs(value) {
+  if (!Array.isArray(value)) return [];
+  return Object.freeze(
+    value.filter(
+      (sourceRef) => isRecord(sourceRef) && typeof sourceRef.kind === "string" && sourceRef.kind.length > 0 && typeof sourceRef.id === "string" && sourceRef.id.length > 0
+    ).map((sourceRef) => ({
+      kind: sourceRef.kind,
+      id: sourceRef.id,
+      ...isRecord(sourceRef.metadata) ? { metadata: sourceRef.metadata } : {}
+    }))
+  );
+}
+function runRequestIdentityIssues(request, input) {
+  const refs = sanitizeAdapterInputSourceRefs([
+    ref("tool-provider-adapter-run", request.runId),
+    ref("tool-provider-adapter-input", input.adapterInputId),
+    ...request.sourceRefs ?? []
+  ]);
+  const issues = [];
+  if (request.kind !== "tool-provider-adapter-run-requested") {
+    issues.push(
+      dataIssue(
+        "tool-provider-adapter-run-request-invalid-kind",
+        "Tool provider adapter run request kind must be tool-provider-adapter-run-requested.",
+        { subjectId: request.adapterInputId, refs }
+      )
+    );
+  }
+  if (request.runId.length === 0) {
+    issues.push(
+      dataIssue(
+        "tool-provider-adapter-run-request-missing-run-id",
+        "Tool provider adapter run request requires runId.",
+        {
+          subjectId: request.adapterInputId,
+          refs
+        }
+      )
+    );
+  }
+  if (!Number.isInteger(request.attempt) || request.attempt < 1) {
+    issues.push(
+      dataIssue(
+        "tool-provider-adapter-run-request-invalid-attempt",
+        "Tool provider adapter run request attempt must be a positive integer.",
+        { subjectId: request.adapterInputId, refs }
+      )
+    );
+  }
+  if (request.requestId !== input.requestId) {
+    issues.push(
+      dataIssue(
+        "tool-provider-adapter-run-request-stale-request",
+        "Tool provider adapter run request requestId does not match the adapter input.",
+        { subjectId: input.requestId, refs }
+      )
+    );
+  }
+  if (request.operationId !== input.operationId) {
+    issues.push(
+      dataIssue(
+        "tool-provider-adapter-run-request-stale-operation",
+        "Tool provider adapter run request operationId does not match the adapter input.",
+        { subjectId: input.requestId, refs }
+      )
+    );
+  }
+  if (request.routeId !== void 0 && request.routeId !== input.routeId) {
+    issues.push(
+      dataIssue(
+        "tool-provider-adapter-run-request-stale-route",
+        "Tool provider adapter run request routeId does not match the adapter input.",
+        { subjectId: input.requestId, refs }
+      )
+    );
+  }
+  if (request.providerId !== void 0 && request.providerId !== input.providerId) {
+    issues.push(
+      dataIssue(
+        "tool-provider-adapter-run-request-stale-provider",
+        "Tool provider adapter run request providerId does not match the adapter input.",
+        { subjectId: input.requestId, refs }
+      )
+    );
+  }
+  if (request.executorId !== void 0 && request.executorId !== input.executorId) {
+    issues.push(
+      dataIssue(
+        "tool-provider-adapter-run-request-stale-executor",
+        "Tool provider adapter run request executorId does not match the adapter input.",
+        { subjectId: input.requestId, refs }
+      )
+    );
+  }
+  if (request.profileId !== void 0 && request.profileId !== input.profileId) {
+    issues.push(
+      dataIssue(
+        "tool-provider-adapter-run-request-stale-profile",
+        "Tool provider adapter run request profileId does not match the adapter input.",
+        { subjectId: input.requestId, refs }
+      )
+    );
+  }
+  for (const forbidden of [
+    ...forbiddenDataKeys(request),
+    ...forbiddenProviderRawMaterialKeys(request)
+  ]) {
+    issues.push(
+      dataIssue(
+        "tool-provider-adapter-run-request-forbidden-runtime-material",
+        "Tool provider adapter run request must not contain runtime-private adapter material.",
+        { subjectId: input.requestId, refs, details: { reason: forbidden.reason } }
+      )
+    );
+  }
+  return issues;
+}
+function emitRunRequested(ctx, state, request, privateRetentionHooks) {
+  const key = `${request.runId}:${request.adapterInputId}:${request.attempt}`;
+  if (state.emittedKeys.has(key)) return;
+  state.emittedKeys.add(key);
+  ctx.down([["DATA", { kind: "request", request }]]);
+  privateRetentionHooks?.onRunRequestKey?.({
+    key,
+    request,
+    dropKey: () => state.emittedKeys.delete(key)
+  });
+  emitRunStatus(
+    ctx,
+    state,
+    {
+      kind: "tool-provider-adapter-run-status",
+      runId: request.runId,
+      adapterInputId: request.adapterInputId,
+      requestId: request.requestId,
+      operationId: request.operationId,
+      status: "requested",
+      attempt: request.attempt,
+      sourceRefs: request.sourceRefs
+    },
+    privateRetentionHooks
+  );
+  emitRunAudit(ctx, state, "tool-provider-adapter-run-requested", request, {
+    reason: request.reason,
+    attempt: request.attempt
+  });
+}
+function emitRunStatus(ctx, state, status, privateRetentionHooks) {
+  const cleanSourceRefs = status.sourceRefs === void 0 ? void 0 : sanitizeAdapterInputSourceRefs(status.sourceRefs);
+  const cleanIssues = status.issues === void 0 ? void 0 : Object.freeze(status.issues.map((issue2) => sanitizeAdapterInputIssue(issue2)));
+  const cleanMetadata = sanitizeProviderGraphVisibleRecord(status.metadata);
+  const cleanStatus = Object.freeze({
+    kind: status.kind,
+    runId: status.runId,
+    adapterInputId: status.adapterInputId,
+    ...status.requestId === void 0 ? {} : { requestId: status.requestId },
+    ...status.operationId === void 0 ? {} : { operationId: status.operationId },
+    status: status.status,
+    ...status.attempt === void 0 ? {} : { attempt: status.attempt },
+    ...status.outcomeId === void 0 ? {} : { outcomeId: status.outcomeId },
+    ...cleanIssues === void 0 || cleanIssues.length === 0 ? {} : { issues: cleanIssues },
+    ...cleanSourceRefs === void 0 || cleanSourceRefs.length === 0 ? {} : { sourceRefs: cleanSourceRefs },
+    ...cleanMetadata === void 0 ? {} : { metadata: cleanMetadata }
+  });
+  const key = stableJsonStringify({
+    runId: cleanStatus.runId,
+    adapterInputId: cleanStatus.adapterInputId,
+    requestId: cleanStatus.requestId,
+    attempt: cleanStatus.attempt,
+    status: cleanStatus.status,
+    outcomeId: cleanStatus.outcomeId
+  });
+  if (state.statusKeys.has(key)) return;
+  state.statusKeys.add(key);
+  ctx.down([
+    ["DATA", { kind: "status", status: cleanStatus }]
+  ]);
+  privateRetentionHooks?.onRunStatusKey?.({
+    key,
+    status: cleanStatus,
+    dropKey: () => state.statusKeys.delete(key)
+  });
+}
+function emitRunIssue(ctx, state, code, message, subjectId, refs, privateRetentionHooks) {
+  emitRunIssueFact(
+    ctx,
+    state,
+    dataIssue(code, message, { subjectId, refs }),
+    privateRetentionHooks
+  );
+}
+function emitRunIssueFact(ctx, state, issue2, privateRetentionHooks) {
+  const key = stableJsonStringify({
+    code: issue2.code,
+    subjectId: issue2.subjectId,
+    refs: issue2.refs ?? [],
+    details: issue2.details
+  });
+  if (state.issueKeys.has(key)) return;
+  state.issueKeys.add(key);
+  ctx.down([["DATA", { kind: "issue", issue: issue2 }]]);
+  privateRetentionHooks?.onRunIssueKey?.({
+    key,
+    issue: issue2,
+    dropKey: () => state.issueKeys.delete(key)
+  });
+}
+function emitRunAudit(ctx, state, kind, request, metadata) {
+  state.auditSeq += 1;
+  ctx.down([
+    [
+      "DATA",
+      {
+        kind: "audit",
+        audit: {
+          id: `${request.runId}:audit:${state.auditSeq}`,
+          kind,
+          subjectId: request.requestId,
+          sourceRefs: sanitizeAdapterInputSourceRefs(request.sourceRefs ?? []),
+          metadata: sanitizeProviderGraphVisibleRecord({
+            runId: request.runId,
+            adapterInputId: request.adapterInputId,
+            ...metadata
+          })
+        }
+      }
+    ]
+  ]);
+}
+
+// src/orchestration/agent-runtime-executor-outcome.ts
+function adapterRuntimeIdentity(input) {
+  if (input.status !== "ready") {
+    throw new RangeError("buildToolProviderExecutorOutcome: adapter input must be ready");
+  }
+  if (input.routeId === void 0 || input.executorId === void 0 || input.profileId === void 0) {
+    throw new RangeError(
+      "buildToolProviderExecutorOutcome: ready adapter input is missing route/executor/profile identity"
+    );
+  }
+  return {
+    routeId: input.routeId,
+    executorId: input.executorId,
+    profileId: input.profileId
+  };
+}
+function defaultToolProviderAdapterEvidenceRefs(input) {
+  return sanitizeAdapterInputSourceRefs([
+    ref("tool-provider-adapter-input", input.adapterInputId),
+    ...input.sourceRefs ?? []
+  ]);
+}
+function buildToolProviderExecutorOutcome(input, result, opts = {}) {
+  const ids = adapterRuntimeIdentity(input);
+  const attempt = opts.attempt ?? 1;
+  const occurredAtMs = result.occurredAtMs ?? opts.occurredAtMs;
+  const evidenceRefs = result.evidenceRefs === void 0 ? defaultToolProviderAdapterEvidenceRefs(input) : sanitizeAdapterInputSourceRefs(result.evidenceRefs);
+  const issues = result.issues === void 0 ? void 0 : Object.freeze(
+    result.issues.map((issue3) => sanitizeAdapterInputIssue(issue3, opts.publicText))
+  );
+  const textIssues = [];
+  const metadata = sanitizeRuntimeMetadata(
+    {
+      ...result.metadata ?? {},
+      adapterInputId: input.adapterInputId,
+      ...opts.runId === void 0 ? {} : { runId: opts.runId },
+      providerId: input.providerId,
+      toolName: input.toolName,
+      operation: input.operation
+    },
+    input,
+    opts.publicText,
+    textIssues
+  );
+  if (metadata === void 0 && result.metadata !== void 0) {
+    textIssues.push(
+      dataIssue(
+        "tool-provider-adapter-runtime-metadata-redacted",
+        "Tool provider adapter runtime metadata was omitted because it contained runtime-private material.",
+        {
+          subjectId: input.requestId,
+          refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+          severity: "warning"
+        }
+      )
+    );
+  }
+  const base = {
+    outcomeId: opts.outcomeId ?? `${input.adapterInputId}:${toolProviderOutcomeRunSegment(opts.runId, attempt)}:${result.kind}`,
+    requestId: input.requestId,
+    operationId: input.operationId,
+    routeId: ids.routeId,
+    executorId: ids.executorId,
+    profileId: ids.profileId,
+    attempt,
+    evidenceRefs,
+    ...input.input?.inputId === void 0 ? {} : { inputId: input.input.inputId },
+    ...input.input?.inputKind === void 0 ? {} : { inputKind: input.input.inputKind },
+    ...occurredAtMs === void 0 ? {} : { occurredAtMs },
+    ...issues === void 0 ? {} : { issues },
+    ...result.usage === void 0 ? {} : { usage: result.usage },
+    ...metadata === void 0 ? {} : { metadata }
+  };
+  const candidate = (() => {
+    switch (result.kind) {
+      case "result":
+        return {
+          ...base,
+          kind: "result",
+          result: sanitizeAgentOutputEnvelope(result.result, input, opts.publicText, textIssues)
+        };
+      case "failure":
+        return {
+          ...base,
+          kind: "failure",
+          error: sanitizeAdapterInputIssue(result.error, opts.publicText),
+          ...result.retryable === void 0 ? {} : { retryable: result.retryable }
+        };
+      case "canceled":
+        return {
+          ...base,
+          kind: "canceled",
+          ...result.reason === void 0 ? {} : {
+            reason: boundedPublicText(
+              result.reason,
+              "reason",
+              input,
+              opts.publicText,
+              textIssues
+            )
+          }
+        };
+      case "timeout":
+        return {
+          ...base,
+          kind: "timeout",
+          ...result.timeoutMs === void 0 ? {} : { timeoutMs: result.timeoutMs },
+          ...result.retryable === void 0 ? {} : { retryable: result.retryable }
+        };
+      case "blocked":
+        return {
+          ...base,
+          kind: "blocked",
+          needs: Object.freeze(
+            result.needs.map((need) => sanitizeAgentNeed(need, input, opts.publicText, textIssues))
+          )
+        };
+    }
+  })();
+  const boundedCandidate = textIssues.length === 0 ? candidate : {
+    ...candidate,
+    issues: Object.freeze([...candidate.issues ?? [], ...textIssues])
+  };
+  const materialIssues = (boundedCandidate.issues ?? []).filter(
+    (issue3) => issue3.code === "tool-provider-adapter-runtime-forbidden-runtime-material"
+  );
+  const leakIssues = forbiddenAdapterRuntimeMaterialIssues(
+    boundedCandidate,
+    ref("executor-outcome", boundedCandidate.outcomeId),
+    "executor-outcome"
+  );
+  if (leakIssues.length === 0 && materialIssues.length === 0)
+    return Object.freeze(boundedCandidate);
+  const allLeakIssues = Object.freeze([...materialIssues, ...leakIssues]);
+  const issue2 = allLeakIssues[0] ?? dataIssue("tool-provider-adapter-runtime-invalid", "invalid");
+  const failureMetadata = sanitizeGraphVisibleRecord({
+    adapterInputId: input.adapterInputId,
+    ...opts.runId === void 0 ? {} : { runId: opts.runId },
+    providerId: input.providerId,
+    toolName: input.toolName,
+    operation: input.operation
+  });
+  return Object.freeze({
+    kind: "failure",
+    outcomeId: `${input.adapterInputId}:${toolProviderOutcomeRunSegment(
+      opts.runId,
+      attempt
+    )}:failure`,
+    requestId: input.requestId,
+    operationId: input.operationId,
+    routeId: ids.routeId,
+    executorId: ids.executorId,
+    profileId: ids.profileId,
+    attempt,
+    evidenceRefs,
+    ...input.input?.inputId === void 0 ? {} : { inputId: input.input.inputId },
+    ...input.input?.inputKind === void 0 ? {} : { inputKind: input.input.inputKind },
+    ...occurredAtMs === void 0 ? {} : { occurredAtMs },
+    ...failureMetadata === void 0 ? {} : { metadata: failureMetadata },
+    error: issue2,
+    retryable: false,
+    issues: allLeakIssues
+  });
+}
+function toolProviderOutcomeRunSegment(runId, attempt) {
+  return runId === void 0 ? `attempt-${attempt}` : `${runId}:attempt-${attempt}`;
+}
+function forbiddenAdapterRuntimeMaterialIssues(value, subjectRef, area) {
+  if (value === void 0) return [];
+  const forbidden = publicMaterialForbiddenKeys(value, "provider");
+  if (forbidden.length === 0) return [];
+  return Object.freeze(
+    forbidden.map(
+      (entry) => dataIssue(
+        "tool-provider-adapter-runtime-forbidden-runtime-material",
+        "Tool provider adapter runtime output must not contain runtime-private adapter material.",
+        { subjectId: subjectRef.id, refs: [subjectRef], details: { area, reason: entry.reason } }
+      )
+    )
+  );
+}
+
+// src/orchestration/agent-runtime-tool-provider-policy.ts
+function localBuiltinToolProviderCatalog(opts = {}) {
+  const providerId = opts.providerId ?? "local-builtin";
+  const executorId = opts.executorId ?? `${providerId}:tool-executor`;
+  const profileId = opts.profileId ?? `${providerId}:tool-profile`;
+  const tools = opts.tools ?? [
+    { toolName: "document/read-doc", operation: "read" },
+    { toolName: "file.read", operation: "read" },
+    { toolName: "file.edit/apply-patch", operation: "edit" },
+    { toolName: "bash.run", operation: "run" },
+    { toolName: "url.fetch", operation: "fetch" },
+    { toolName: "date.now", operation: "read" },
+    { toolName: "weather.fetch", operation: "fetch" },
+    { toolName: "calculator/eval", operation: "eval" }
+  ];
+  const candidatePolicies = opts.policies?.map(
+    (policy) => Object.freeze(policy)
+  ) ?? [
+    defaultLocalBuiltinToolProviderExecutionPolicy({
+      providerId,
+      profileId,
+      tools,
+      overrides: opts.policyOverrides
+    })
+  ];
+  const policyIssues = Object.freeze(
+    candidatePolicies.flatMap((policy) => [
+      ...validateToolProviderExecutionPolicy(policy),
+      ...validateToolProviderPolicyProviderScope(policy, providerId)
+    ])
+  );
+  const policies = Object.freeze(
+    candidatePolicies.filter((policy) => isPublishableToolProviderExecutionPolicy(policy, providerId)).map((policy) => Object.freeze(policy))
+  );
+  const policyRefs = Object.freeze(
+    policies.map((policy) => ref("tool-provider-execution-policy", policy.policyId))
+  );
+  const catalogInputIssues = Object.freeze([
+    ...forbiddenGraphVisibleMaterialIssues(
+      opts.metadata,
+      ref("tool-provider-catalog", providerId),
+      "catalog-metadata"
+    ),
+    ...forbiddenGraphVisibleMaterialIssues(
+      opts.capabilities,
+      ref("executor-profile", profileId),
+      "profile-capabilities"
+    ),
+    ...forbiddenGraphVisibleMaterialIssues(
+      opts.limits,
+      ref("executor-profile", profileId),
+      "profile-limits"
+    ),
+    ...tools.flatMap((tool) => [
+      ...forbiddenGraphVisibleMaterialIssues(
+        tool.metadata,
+        ref("tool", tool.toolName),
+        "tool-metadata"
+      ),
+      ...forbiddenGraphVisibleMaterialIssues(
+        tool.capabilities,
+        ref("tool", tool.toolName),
+        "tool-capabilities"
+      ),
+      ...forbiddenGraphVisibleMaterialIssues(
+        tool.limits,
+        ref("tool", tool.toolName),
+        "tool-limits"
+      )
+    ])
+  ]);
+  const toolEntries = tools.map((tool) => {
+    const toolPolicyRefs = policyRefsForTool(policies, profileId, tool);
+    return Object.freeze({
+      ...tool,
+      kind: "tool-catalog-entry",
+      providerId,
+      inputKind: "tool-call",
+      profileId,
+      executorId,
+      capabilities: sanitizeProviderGraphVisibleRecord(tool.capabilities),
+      limits: sanitizeProviderGraphVisibleRecord(tool.limits),
+      policyRefs: toolPolicyRefs,
+      metadata: sanitizeProviderGraphVisibleRecord(tool.metadata)
+    });
+  });
+  const profilePolicyRefs = policyRefsForProfile(policies, profileId);
+  const issues = Object.freeze([...policyIssues, ...catalogInputIssues]);
+  return Object.freeze({
+    kind: "tool-provider-catalog",
+    providerId,
+    providerKind: "local-builtin",
+    status: issues.length === 0 ? "ready" : "misconfigured",
+    profiles: Object.freeze([
+      Object.freeze({
+        profileId,
+        executorId,
+        kind: "tool",
+        acceptedInputKinds: Object.freeze(["tool-call"]),
+        acceptedResultKinds: Object.freeze(
+          Array.from(new Set(toolEntries.flatMap((tool) => tool.resultKinds ?? [])))
+        ),
+        capabilities: Object.freeze({
+          toolNames: Object.freeze(toolEntries.map((tool) => tool.toolName)),
+          ...sanitizeProviderGraphVisibleRecord(opts.capabilities) ?? {}
+        }),
+        limits: sanitizeProviderGraphVisibleRecord(opts.limits),
+        policyRefs: profilePolicyRefs,
+        metadata: sanitizeProviderGraphVisibleRecord(opts.metadata)
+      })
+    ]),
+    tools: Object.freeze(toolEntries),
+    policies,
+    policyRefs,
+    issues: issues.length === 0 ? void 0 : issues,
+    metadata: sanitizeProviderGraphVisibleRecord(opts.metadata)
+  });
+}
+function validateToolProviderExecutionPolicy(policy) {
+  const issues = [];
+  if (!isRecord(policy)) {
+    return Object.freeze([
+      dataIssue(
+        "tool-provider-policy-invalid-shape",
+        "Tool provider policy must be a data object.",
+        { refs: [ref("tool-provider-execution-policy", "<invalid>")] }
+      )
+    ]);
+  }
+  const policyId = typeof policy.policyId === "string" ? policy.policyId : "";
+  const providerId = typeof policy.providerId === "string" ? policy.providerId : "";
+  const policyRef = ref("tool-provider-execution-policy", policyId || "<missing>");
+  if (policy.kind !== "tool-provider-execution-policy") {
+    issues.push(
+      dataIssue(
+        "tool-provider-policy-invalid-kind",
+        "ToolProviderExecutionPolicy.kind must be tool-provider-execution-policy.",
+        { subjectId: policyId, refs: [policyRef] }
+      )
+    );
+  }
+  if (!policyId) {
+    issues.push(
+      dataIssue(
+        "tool-provider-policy-missing-policy-id",
+        "Tool provider policy is missing policyId.",
+        {
+          refs: [policyRef]
+        }
+      )
+    );
+  }
+  if (!providerId) {
+    issues.push(
+      dataIssue(
+        "tool-provider-policy-missing-provider-id",
+        "Tool provider policy is missing providerId.",
+        { subjectId: policyId, refs: [policyRef] }
+      )
+    );
+  }
+  if (policy.sizeCapacity === void 0 && policy.timeout === void 0 && policy.redaction === void 0 && policy.filesystem === void 0 && policy.approval === void 0 && policy.artifacts === void 0 && policy.network === void 0) {
+    issues.push(
+      dataIssue(
+        "tool-provider-policy-missing-material",
+        "Tool provider policy has no D360 policy material sections.",
+        { subjectId: policyId, refs: [policyRef] }
+      )
+    );
+  }
+  if (policy.sizeCapacity !== void 0 && !isRecord(policy.sizeCapacity)) {
+    issues.push(
+      dataIssue(
+        "tool-provider-policy-invalid-size-capacity",
+        "Tool provider size-capacity policy must be a data object.",
+        { subjectId: policyId, refs: [policyRef] }
+      )
+    );
+  }
+  const limits = isRecord(policy.sizeCapacity) ? policy.sizeCapacity.limits : void 0;
+  if (isRecord(policy.sizeCapacity) && !Array.isArray(limits)) {
+    issues.push(
+      dataIssue(
+        "tool-provider-policy-invalid-size-capacity",
+        "Tool provider size-capacity limits must be an array.",
+        { subjectId: policyId, refs: [policyRef] }
+      )
+    );
+  }
+  for (const [index, rawLimit] of (Array.isArray(limits) ? limits : []).entries()) {
+    if (!isRecord(rawLimit)) {
+      issues.push(
+        dataIssue(
+          "tool-provider-policy-invalid-size-limit",
+          "Tool provider size-capacity limit must be a data object.",
+          { subjectId: policyId, refs: [policyRef], details: { index } }
+        )
+      );
+      continue;
+    }
+    const limit = rawLimit;
+    if (typeof limit.unit !== "string" || limit.unit.length === 0) {
+      issues.push(
+        dataIssue(
+          "tool-provider-policy-invalid-size-limit",
+          "Tool provider size-capacity limit unit must be a non-empty string.",
+          { subjectId: policyId, refs: [policyRef], details: { index } }
+        )
+      );
+    }
+    if (limit.softLimit !== void 0 && (typeof limit.softLimit !== "number" || !Number.isFinite(limit.softLimit) || limit.softLimit < 0)) {
+      issues.push(
+        dataIssue(
+          "tool-provider-policy-invalid-size-limit",
+          "Tool provider size-capacity softLimit must be a finite non-negative number.",
+          { subjectId: policyId, refs: [policyRef], details: { index, unit: limit.unit } }
+        )
+      );
+    }
+    if (limit.hardLimit !== void 0 && (typeof limit.hardLimit !== "number" || !Number.isFinite(limit.hardLimit) || limit.hardLimit < 0)) {
+      issues.push(
+        dataIssue(
+          "tool-provider-policy-invalid-size-limit",
+          "Tool provider size-capacity hardLimit must be a finite non-negative number.",
+          { subjectId: policyId, refs: [policyRef], details: { index, unit: limit.unit } }
+        )
+      );
+    }
+    if (typeof limit.softLimit === "number" && Number.isFinite(limit.softLimit) && typeof limit.hardLimit === "number" && Number.isFinite(limit.hardLimit) && limit.softLimit > limit.hardLimit) {
+      issues.push(
+        dataIssue(
+          "tool-provider-policy-invalid-size-limit",
+          "Tool provider size-capacity softLimit must not exceed hardLimit.",
+          { subjectId: policyId, refs: [policyRef], details: { index, unit: limit.unit } }
+        )
+      );
+    }
+  }
+  if (policy.timeout !== void 0 && !isRecord(policy.timeout)) {
+    issues.push(
+      dataIssue(
+        "tool-provider-policy-invalid-timeout",
+        "Tool provider timeout policy must be a data object.",
+        { subjectId: policyId, refs: [policyRef] }
+      )
+    );
+  }
+  for (const [field, value] of Object.entries(isRecord(policy.timeout) ? policy.timeout : {})) {
+    if (field.endsWith("TimeoutMs") || field === "timeoutMs") {
+      if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+        issues.push(
+          dataIssue(
+            "tool-provider-policy-invalid-timeout",
+            "Tool provider timeout values must be finite non-negative numbers.",
+            { subjectId: policyId, refs: [policyRef], details: { field } }
+          )
+        );
+      }
+    }
+  }
+  for (const forbidden of [
+    ...forbiddenDataKeys(policy),
+    ...forbiddenProviderRawMaterialKeys(policy)
+  ]) {
+    issues.push(
+      dataIssue(
+        "tool-provider-policy-forbidden-runtime-material",
+        "Tool provider policy must not contain runtime-private adapter material.",
+        { subjectId: policyId, refs: [policyRef], details: { reason: forbidden.reason } }
+      )
+    );
+  }
+  return Object.freeze(issues);
+}
+function isPublishableToolProviderExecutionPolicy(policy, providerId) {
+  return isRecord(policy) && policy.kind === "tool-provider-execution-policy" && typeof policy.policyId === "string" && policy.policyId.length > 0 && typeof policy.providerId === "string" && policy.providerId.length > 0 && (providerId === void 0 || policy.providerId === providerId) && validateToolProviderExecutionPolicy(policy).length === 0;
+}
+function validateToolProviderPolicyProviderScope(policy, providerId) {
+  if (!isRecord(policy)) return [];
+  if (policy.providerId === void 0 || policy.providerId === providerId) return [];
+  return Object.freeze([
+    dataIssue(
+      "tool-provider-policy-provider-mismatch",
+      "Tool provider policy providerId must match the catalog providerId.",
+      {
+        subjectId: typeof policy.policyId === "string" ? policy.policyId : void 0,
+        refs: [
+          ref(
+            "tool-provider-execution-policy",
+            typeof policy.policyId === "string" && policy.policyId.length > 0 ? policy.policyId : "<missing>"
+          ),
+          ref("tool-provider-catalog", providerId)
+        ]
+      }
+    )
+  ]);
+}
+function policyRefsForProfile(policies, profileId) {
+  return Object.freeze(
+    policies.filter((policy) => policyAppliesToProfile(policy, profileId)).map((policy) => ref("tool-provider-execution-policy", policy.policyId))
+  );
+}
+function policyRefsForTool(policies, profileId, tool) {
+  return Object.freeze(
+    policies.filter((policy) => policyAppliesToProfile(policy, profileId)).filter((policy) => policyAppliesToOptionalScope(policy.toolNames, tool.toolName)).filter((policy) => policyAppliesToOptionalScope(policy.operations, tool.operation)).map((policy) => ref("tool-provider-execution-policy", policy.policyId))
+  );
+}
+function policyAppliesToProfile(policy, profileId) {
+  return policyAppliesToOptionalScope(policy.profileIds, profileId);
+}
+function policyAppliesToOptionalScope(scope, value) {
+  return scope === void 0 || scope.length === 0 || value !== void 0 && scope.includes(value);
+}
+function defaultLocalBuiltinToolProviderExecutionPolicy(opts) {
+  const toolNames = Object.freeze(Array.from(new Set(opts.tools.map((tool) => tool.toolName))));
+  const operations = Object.freeze(
+    Array.from(new Set(opts.tools.map((tool) => tool.operation).filter((op) => op !== void 0)))
+  );
+  const hasUrlFetch = toolNames.includes("url.fetch");
+  const filesystemToolNames = toolNames.filter(
+    (toolName) => toolName.startsWith("file.") || toolName.startsWith("document/") || toolName === "bash.run"
+  );
+  const approvalToolNames = toolNames.filter(
+    (toolName) => toolName === "file.edit/apply-patch" || toolName === "bash.run"
+  );
+  const approvalOperations = operations.filter(
+    (operation) => operation === "edit" || operation === "run"
+  );
+  const policy = {
+    kind: "tool-provider-execution-policy",
+    policyId: `${opts.providerId}:policy:default`,
+    providerId: opts.providerId,
+    profileIds: Object.freeze([opts.profileId]),
+    toolNames,
+    operations,
+    sizeCapacity: Object.freeze({
+      limits: Object.freeze([
+        Object.freeze({
+          unit: "chars",
+          softLimit: 16384,
+          hardLimit: 65536,
+          perRequest: true,
+          measurementSource: "adapter-estimated"
+        }),
+        Object.freeze({
+          unit: "bytes",
+          softLimit: 1048576,
+          hardLimit: 8388608,
+          perArtifact: true,
+          measurementSource: "adapter-measured"
+        }),
+        Object.freeze({
+          unit: "lines",
+          softLimit: 2e3,
+          hardLimit: 1e4,
+          perStream: true,
+          measurementSource: "adapter-measured"
+        })
+      ])
+    }),
+    timeout: Object.freeze({
+      timeoutMs: 3e4,
+      idleTimeoutMs: 5e3
+    }),
+    redaction: Object.freeze({
+      mode: "summary",
+      sensitivity: Object.freeze(["private-material", "auth-material", "personal-data"]),
+      summaryMaxChars: 512
+    }),
+    ...filesystemToolNames.length > 0 ? {
+      filesystem: Object.freeze({
+        cwd: ".",
+        allowRead: true,
+        allowWrite: false,
+        followSymlinks: false,
+        sourceRefs: Object.freeze(filesystemToolNames.map((toolName) => ref("tool", toolName))),
+        pathRules: Object.freeze([
+          Object.freeze({
+            effect: "allow",
+            path: ".",
+            operation: "read",
+            reason: "Default local builtin catalog is workspace-relative data material."
+          }),
+          Object.freeze({
+            effect: "deny",
+            glob: "**/.env*",
+            reason: "D360 policies keep private material outside catalog DATA."
+          })
+        ])
+      })
+    } : {},
+    ...hasUrlFetch ? {
+      network: Object.freeze({
+        mode: "custom",
+        protocols: Object.freeze(["https:"]),
+        allowedHosts: Object.freeze(["*"]),
+        sourceRefs: Object.freeze([ref("tool", "url.fetch")])
+      })
+    } : {},
+    approval: Object.freeze({
+      mode: approvalToolNames.length > 0 ? "require" : "auto",
+      ...approvalToolNames.length > 0 ? { requiredForToolNames: Object.freeze(approvalToolNames) } : {},
+      ...approvalOperations.length > 0 ? { requiredForOperations: Object.freeze(approvalOperations) } : {}
+    }),
+    artifacts: Object.freeze({
+      defaultDataMode: "summary",
+      artifactKinds: Object.freeze([
+        "text",
+        "markdown",
+        "file",
+        "stdout",
+        "stderr",
+        "tool-output",
+        "provider-raw"
+      ]),
+      inlineLimits: Object.freeze([
+        Object.freeze({
+          unit: "chars",
+          hardLimit: 4096,
+          perArtifact: true,
+          measurementSource: "adapter-estimated"
+        })
+      ]),
+      requireDigest: false
+    }),
+    sourceRefs: Object.freeze([ref("decision", "D360"), ref("tool-provider", opts.providerId)]),
+    metadata: Object.freeze({
+      description: "Default data-only policy material for local builtin tools."
+    }),
+    ...unlockedToolProviderPolicyOverrides(opts.overrides)
+  };
+  return Object.freeze(policy);
+}
+
+// src/executors/tool-provider-adapters.ts
+var LOCAL_BUILTIN_TOOLS = Object.freeze([
+  Object.freeze({
+    toolName: "date.now",
+    operation: "read",
+    resultKinds: Object.freeze(["json"]),
+    capabilities: Object.freeze({ deterministicWithInjectedClock: true })
+  }),
+  Object.freeze({
+    toolName: "json.parse",
+    operation: "parse",
+    resultKinds: Object.freeze(["json"]),
+    capabilities: Object.freeze({ externalSideEffects: false })
+  }),
+  Object.freeze({
+    toolName: "text.concat",
+    operation: "transform",
+    resultKinds: Object.freeze(["text"]),
+    capabilities: Object.freeze({ externalSideEffects: false })
+  })
+]);
+function localBuiltinToolProviderBinding(opts = {}) {
+  const providerId = opts.providerId ?? "local-builtin";
+  const maxTextChars = nonNegativeFinite(opts.maxTextChars, 16384);
+  return Object.freeze({
+    providerId,
+    run(input, ctx) {
+      const toolName = input.toolName;
+      switch (toolName) {
+        case "date.now":
+          return localDateNow(input, ctx, opts.now);
+        case "json.parse":
+          return localJsonParse(input, maxTextChars);
+        case "text.concat":
+          return localTextConcat(input, maxTextChars);
+        default:
+          return blocked(
+            input,
+            "local-builtin-unsupported-tool",
+            "Local builtin tool is not supported."
+          );
+      }
+    }
+  });
+}
+function localBuiltinToolProviderAdapterPack(opts = {}) {
+  const providerId = opts.providerId ?? "local-builtin";
+  const catalog = localBuiltinToolProviderCatalog({
+    providerId,
+    executorId: opts.executorId ?? `${providerId}:tool-executor`,
+    profileId: opts.profileId ?? `${providerId}:tool-profile`,
+    tools: LOCAL_BUILTIN_TOOLS,
+    policyOverrides: {
+      operations: Object.freeze(["read", "parse", "transform"]),
+      redaction: Object.freeze({
+        mode: "summary",
+        summaryMaxChars: opts.publicText?.maxSummaryChars ?? 512
+      })
+    },
+    metadata: Object.freeze({ adapterPack: "local-builtin-v0" })
+  });
+  return Object.freeze({
+    catalogs: Object.freeze([catalog]),
+    bindings: Object.freeze([
+      localBuiltinToolProviderBinding({
+        providerId,
+        now: opts.now,
+        maxTextChars: opts.maxTextChars ?? opts.publicText?.maxSummaryChars
+      })
+    ])
+  });
+}
+function processToolProviderBinding(opts = {}) {
+  const providerId = opts.providerId ?? "process";
+  const config = processConfig(opts);
+  return Object.freeze({
+    providerId,
+    run(input) {
+      const args = processArguments(input);
+      if (args === void 0) {
+        return blocked(input, "process-invalid-arguments", "Process tool requires argv arguments.");
+      }
+      const allowed = config.allowedCommands.get(args.command);
+      if (allowed === void 0) {
+        if (config.duplicateCommands.has(args.command)) {
+          return blocked(
+            input,
+            "process-command-duplicate-allowlist",
+            "Process command has duplicate allowlist entries."
+          );
+        }
+        if (config.invalidCommands.has(args.command)) {
+          return blocked(
+            input,
+            "process-command-invalid-allowlist",
+            "Process command has an invalid allowlist entry."
+          );
+        }
+        return blocked(input, "process-command-not-allowed", "Process command is not allowlisted.");
+      }
+      if (!argsAllowed(allowed, args.args)) {
+        return blocked(input, "process-argv-not-allowed", "Process argv is not allowlisted.");
+      }
+      const cwd = resolveProcessCwd(args.cwd, allowed, config);
+      if (cwd === void 0) {
+        return blocked(
+          input,
+          "process-cwd-not-allowed",
+          "Process cwd is outside the allowed policy."
+        );
+      }
+      const env = processEnv(args.env, config);
+      if (env === void 0) {
+        return blocked(
+          input,
+          "process-env-not-allowed",
+          "Process env contains non-allowlisted keys."
+        );
+      }
+      return runProcessTool(input, allowed, args, cwd, env, config);
+    }
+  });
+}
+function processToolProviderAdapterPack(opts = {}) {
+  const providerId = opts.providerId ?? "process";
+  const executorId = opts.executorId ?? `${providerId}:tool-executor`;
+  const profileId = opts.profileId ?? `${providerId}:tool-profile`;
+  return Object.freeze({
+    catalogs: Object.freeze([
+      processToolProviderCatalog({ ...opts, providerId, executorId, profileId })
+    ]),
+    bindings: Object.freeze([processToolProviderBinding({ ...opts, providerId })])
+  });
+}
+function processToolProviderCatalog(opts = {}) {
+  const providerId = opts.providerId ?? "process";
+  const executorId = opts.executorId ?? `${providerId}:tool-executor`;
+  const profileId = opts.profileId ?? `${providerId}:tool-profile`;
+  const normalized = normalizeAllowedCommands(opts.allowedCommands ?? []);
+  const allowedCommands = Object.freeze([...normalized.commands.values()]);
+  const issueList = [
+    ...allowedCommands.length === 0 ? [
+      issue(
+        "process-tool-provider-empty-allowlist",
+        "Process tool provider has no allowlisted commands and will deny execution.",
+        "warning"
+      )
+    ] : [],
+    ...[...normalized.duplicates].map(
+      (command) => issue(
+        "process-tool-provider-duplicate-allowlist",
+        "Process tool provider has duplicate command allowlist entries.",
+        "error",
+        { command }
+      )
+    ),
+    ...[...normalized.invalids].map(
+      (command) => issue(
+        "process-tool-provider-invalid-allowlist",
+        "Process tool provider has invalid command allowlist entries.",
+        "error",
+        { command }
+      )
+    )
+  ];
+  const issues = issueList.length === 0 ? void 0 : Object.freeze(issueList);
+  const policy = processToolProviderExecutionPolicy(providerId, profileId, opts);
+  const tool = Object.freeze({
+    kind: "tool-catalog-entry",
+    providerId,
+    toolName: "process.execFile",
+    operation: "run",
+    inputKind: "tool-call",
+    profileId,
+    executorId,
+    resultKinds: Object.freeze(["process-result"]),
+    capabilities: Object.freeze({
+      argv: true,
+      shell: false,
+      commands: Object.freeze(allowedCommands.map((cmd) => cmd.command)),
+      env: Object.freeze({ allowedKeys: Object.freeze([...opts.allowedEnvKeys ?? []]) })
+    }),
+    policyRefs: Object.freeze([{ kind: "tool-provider-execution-policy", id: policy.policyId }])
+  });
+  return Object.freeze({
+    kind: "tool-provider-catalog",
+    providerId,
+    providerKind: "process",
+    status: issues === void 0 ? "ready" : "misconfigured",
+    profiles: Object.freeze([
+      Object.freeze({
+        profileId,
+        executorId,
+        kind: "tool",
+        acceptedInputKinds: Object.freeze(["tool-call"]),
+        acceptedResultKinds: Object.freeze(["process-result"]),
+        capabilities: Object.freeze({
+          toolNames: Object.freeze([tool.toolName]),
+          argv: true,
+          shell: false
+        }),
+        policyRefs: Object.freeze([
+          { kind: "tool-provider-execution-policy", id: policy.policyId }
+        ])
+      })
+    ]),
+    tools: Object.freeze([tool]),
+    policies: Object.freeze([policy]),
+    policyRefs: Object.freeze([{ kind: "tool-provider-execution-policy", id: policy.policyId }]),
+    issues,
+    metadata: Object.freeze({ adapterPack: "process-v0" })
+  });
+}
+function httpToolProviderCatalog(opts = {}) {
+  const providerId = opts.providerId ?? "http";
+  const executorId = opts.executorId ?? `${providerId}:tool-executor`;
+  const profileId = opts.profileId ?? `${providerId}:tool-profile`;
+  const allowedOrigins = Object.freeze([...opts.allowedOrigins ?? []]);
+  const allowedMethods = Object.freeze(normalizeMethods(opts.allowedMethods ?? ["GET"]));
+  const maxResponseBytes = Math.max(1, nonNegativeFinite(opts.maxResponseBytes, 64 * 1024));
+  const policy = httpToolProviderExecutionPolicy(providerId, profileId, opts);
+  const issues = Object.freeze([
+    ...allowedOrigins.length === 0 ? [
+      issue(
+        "http-tool-provider-empty-origin-allowlist",
+        "HTTP tool provider has no allowlisted origins and will deny execution.",
+        "warning"
+      )
+    ] : [],
+    ...allowedMethods.length === 0 ? [
+      issue(
+        "http-tool-provider-empty-method-allowlist",
+        "HTTP tool provider has no allowlisted methods and will deny execution."
+      )
+    ] : []
+  ]);
+  const tool = Object.freeze({
+    kind: "tool-catalog-entry",
+    providerId,
+    toolName: "http.fetch",
+    operation: "fetch",
+    inputKind: "tool-call",
+    profileId,
+    executorId,
+    resultKinds: Object.freeze(["http-result"]),
+    capabilities: Object.freeze({
+      origins: allowedOrigins,
+      methods: allowedMethods,
+      maxResponseBytes,
+      asyncRuntime: true
+    }),
+    policyRefs: Object.freeze([{ kind: "tool-provider-execution-policy", id: policy.policyId }])
+  });
+  return Object.freeze({
+    kind: "tool-provider-catalog",
+    providerId,
+    providerKind: "http",
+    status: issues.length === 0 ? "ready" : "misconfigured",
+    profiles: Object.freeze([
+      Object.freeze({
+        profileId,
+        executorId,
+        kind: "tool",
+        acceptedInputKinds: Object.freeze(["tool-call"]),
+        acceptedResultKinds: Object.freeze(["http-result"]),
+        capabilities: Object.freeze({
+          toolNames: Object.freeze([tool.toolName]),
+          asyncRuntime: true
+        }),
+        policyRefs: Object.freeze([
+          { kind: "tool-provider-execution-policy", id: policy.policyId }
+        ])
+      })
+    ]),
+    tools: Object.freeze([tool]),
+    policies: Object.freeze([policy]),
+    policyRefs: Object.freeze([{ kind: "tool-provider-execution-policy", id: policy.policyId }]),
+    issues: issues.length === 0 ? void 0 : issues,
+    metadata: Object.freeze({ adapterPack: "http-v0", asyncRuntime: true })
+  });
+}
+function httpToolProviderRuntime(graph, opts) {
+  const name = opts.name ?? "httpToolProviderRuntime";
+  const providerId = opts.providerId ?? "http";
+  const catalog = httpToolProviderCatalog(opts);
+  const outcomes = graph.node([], null, {
+    name: `${name}/outcomes`
+  });
+  const runStatus = graph.node([], null, {
+    name: `${name}/runStatus`
+  });
+  const status = graph.node([], null, { name: `${name}/status` });
+  const issues = graph.node([], null, { name: `${name}/issues` });
+  const audit = graph.node([], null, { name: `${name}/audit` });
+  const inputs = /* @__PURE__ */ new Map();
+  const executions = /* @__PURE__ */ new Set();
+  const active = /* @__PURE__ */ new Set();
+  const config = httpRuntimeConfig(opts);
+  const driver = opts.driver ?? defaultHttpToolProviderDriver(config.maxResponseBytes);
+  const forwardedRunStatusKeys = /* @__PURE__ */ new Set();
+  let auditSeq = 0;
+  let disposed = false;
+  function nowMs() {
+    return opts.now?.();
+  }
+  function publishIssue(nextIssue) {
+    issues.down([["DATA", nextIssue]]);
+  }
+  function publishAudit(kind, subjectId, metadata, issueCode) {
+    auditSeq += 1;
+    audit.down([
+      [
+        "DATA",
+        {
+          id: `${name}:audit:${auditSeq}`,
+          kind,
+          subjectId,
+          ...issueCode === void 0 ? {} : { issueCode },
+          ...metadata === void 0 ? {} : { metadata }
+        }
+      ]
+    ]);
+  }
+  function publishRunStatus(request, nextStatus, statusIssues, outcomeId) {
+    forwardedRunStatusKeys.add(`${request.runId}:${nextStatus}`);
+    runStatus.down([
+      [
+        "DATA",
+        {
+          kind: "tool-provider-adapter-run-status",
+          runId: request.runId,
+          adapterInputId: request.adapterInputId,
+          requestId: request.requestId,
+          operationId: request.operationId,
+          status: nextStatus,
+          attempt: request.attempt,
+          ...outcomeId === void 0 ? {} : { outcomeId },
+          ...statusIssues === void 0 ? {} : { issues: statusIssues },
+          sourceRefs: request.sourceRefs,
+          metadata: Object.freeze({ providerId, reason: request.reason })
+        }
+      ]
+    ]);
+  }
+  function publishRequestStatus(input, nextStatus, statusIssues) {
+    if (input.effectRunId === void 0) return;
+    status.down([
+      [
+        "DATA",
+        {
+          kind: "status",
+          requestId: input.requestId,
+          operationId: input.operationId,
+          effectRunId: input.effectRunId,
+          status: nextStatus,
+          sourceRefs: defaultEvidenceRefs(input),
+          ...statusIssues === void 0 ? {} : { issues: statusIssues },
+          metadata: Object.freeze({
+            adapterInputId: input.adapterInputId,
+            providerId: input.providerId,
+            toolName: input.toolName
+          })
+        }
+      ]
+    ]);
+  }
+  function publishOutcome(input, request, result) {
+    const outcome = buildToolProviderExecutorOutcome(input, result, {
+      runId: request.runId,
+      attempt: request.attempt,
+      occurredAtMs: nowMs(),
+      publicText: opts.publicText
+    });
+    outcomes.down([["DATA", outcome]]);
+    const statusIssues = outcomeIssues(outcome);
+    for (const statusIssue of statusIssues) publishIssue(statusIssue);
+    publishRequestStatus(input, agentStatusForOutcome(outcome), statusIssues);
+    publishRunStatus(request, outcome.kind, statusIssues, outcome.outcomeId);
+    publishAudit("http-tool-provider-runtime-finished", input.requestId, {
+      runId: request.runId,
+      attempt: request.attempt,
+      status: outcome.kind,
+      outcomeId: outcome.outcomeId
+    });
+  }
+  function execute(request) {
+    if (disposed || request.providerId !== void 0 && request.providerId !== providerId) return;
+    const input = inputs.get(request.adapterInputId);
+    if (input === void 0 || input.providerId !== providerId) return;
+    const coordinate = `${request.runId}:${request.adapterInputId}:${request.attempt}`;
+    if (executions.has(coordinate)) return;
+    executions.add(coordinate);
+    publishRunStatus(request, "requested");
+    if (input.status !== "ready") {
+      const inputIssue = issue(
+        "http-tool-provider-input-not-ready",
+        "HTTP tool provider runtime requires a ready adapter input."
+      );
+      publishIssue(inputIssue);
+      publishRunStatus(request, "stale-request", [inputIssue]);
+      publishRequestStatus(input, "blocked", [inputIssue]);
+      return;
+    }
+    if (!requestMatchesInput(request, input)) {
+      const mismatch = issue(
+        "http-tool-provider-run-request-mismatched-input",
+        "HTTP tool provider run request does not match its adapter input."
+      );
+      publishIssue(mismatch);
+      publishRunStatus(request, "mismatched-request", [mismatch]);
+      publishRequestStatus(input, "blocked", [mismatch]);
+      return;
+    }
+    const prepared = prepareHttpRequest(input, config);
+    if (prepared.kind === "blocked") {
+      publishOutcome(input, request, {
+        kind: "blocked",
+        needs: Object.freeze([
+          Object.freeze({
+            kind: prepared.issue.code,
+            message: prepared.issue.message
+          })
+        ]),
+        issues: Object.freeze([prepared.issue]),
+        evidenceRefs: defaultEvidenceRefs(input)
+      });
+      return;
+    }
+    if (config.approvalMode === "never") {
+      publishOutcome(input, request, {
+        kind: "blocked",
+        needs: Object.freeze([
+          Object.freeze({
+            kind: "tool-provider-approval-disabled",
+            message: "HTTP tool provider policy disallows execution."
+          })
+        ]),
+        issues: Object.freeze([
+          issue("http-tool-provider-approval-never", "HTTP tool provider execution is disabled.")
+        ]),
+        evidenceRefs: defaultEvidenceRefs(input)
+      });
+      return;
+    }
+    if (config.approvalMode === "require" && !requestApproved(request)) {
+      publishOutcome(input, request, {
+        kind: "blocked",
+        needs: Object.freeze([
+          Object.freeze({
+            kind: "tool-provider-approval",
+            message: "HTTP tool provider execution requires a visible approval run request."
+          })
+        ]),
+        issues: Object.freeze([
+          issue(
+            "http-tool-provider-approval-required",
+            "HTTP tool provider execution requires approval."
+          )
+        ]),
+        evidenceRefs: defaultEvidenceRefs(input)
+      });
+      return;
+    }
+    const controller = new AbortController();
+    active.add(controller);
+    publishRunStatus(request, "started");
+    publishRequestStatus(input, "in-flight");
+    publishAudit("http-tool-provider-runtime-started", input.requestId, {
+      runId: request.runId,
+      attempt: request.attempt,
+      method: prepared.request.method,
+      origin: new URL(prepared.request.url).origin
+    });
+    const timeout = setTimeout(() => controller.abort(), config.timeoutMs);
+    Promise.resolve(driver.fetch({ ...prepared.request, signal: controller.signal })).then(
+      (response) => {
+        clearTimeout(timeout);
+        active.delete(controller);
+        if (disposed) return;
+        publishOutcome(input, request, httpResponseResult(prepared.request, response, config));
+      },
+      (error) => {
+        clearTimeout(timeout);
+        active.delete(controller);
+        if (disposed) return;
+        publishOutcome(input, request, httpErrorResult(error, config));
+      }
+    );
+  }
+  const unsubscribeInputs = opts.inputs.subscribe((msg) => {
+    if (msg[0] !== "DATA") return;
+    const input = msg[1];
+    if (input.providerId === providerId) inputs.set(input.adapterInputId, input);
+  });
+  const autoRunReadyInputs = opts.autoRunReadyInputs ?? (opts.runRequests === void 0 || opts.runRequests.length === 0);
+  const runProjector = toolProviderAdapterRunProjector(graph, {
+    name: `${name}/runs`,
+    inputs: opts.inputs,
+    runRequests: opts.runRequests,
+    autoRunReadyInputs,
+    now: opts.now
+  });
+  const unsubscribeRunStatus = runProjector.status.subscribe((msg) => {
+    if (msg[0] !== "DATA") return;
+    const nextStatus = msg[1];
+    const statusKey = `${nextStatus.runId}:${nextStatus.status}`;
+    if (forwardedRunStatusKeys.has(statusKey)) return;
+    forwardedRunStatusKeys.add(statusKey);
+    runStatus.down([["DATA", nextStatus]]);
+  });
+  const unsubscribeRunIssues = runProjector.issues.subscribe((msg) => {
+    if (msg[0] === "DATA") publishIssue(msg[1]);
+  });
+  const unsubscribeRunAudit = runProjector.audit.subscribe((msg) => {
+    if (msg[0] === "DATA") audit.down([["DATA", msg[1]]]);
+  });
+  const unsubscribeRunRequests = runProjector.requests.subscribe((msg) => {
+    if (msg[0] === "DATA") execute(msg[1]);
+  });
+  return Object.freeze({
+    catalogs: Object.freeze([catalog]),
+    runRequests: runProjector.requests,
+    runStatus,
+    outcomes,
+    status,
+    issues,
+    audit,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      unsubscribeInputs();
+      unsubscribeRunStatus();
+      unsubscribeRunIssues();
+      unsubscribeRunAudit();
+      unsubscribeRunRequests();
+      for (const controller of active) controller.abort();
+      active.clear();
+    }
+  });
+}
+function localDateNow(input, ctx, now) {
+  const epochMs = now?.() ?? ctx.now?.() ?? Date.now();
+  return Object.freeze({
+    kind: "result",
+    result: Object.freeze({
+      kind: "json",
+      value: Object.freeze({
+        toolName: "date.now",
+        epochMs,
+        iso: new Date(epochMs).toISOString()
+      }),
+      summary: String(epochMs)
+    }),
+    occurredAtMs: epochMs,
+    evidenceRefs: input.sourceRefs
+  });
+}
+function localJsonParse(input, maxTextChars) {
+  const text = input.toolCall?.arguments?.text;
+  if (typeof text !== "string") {
+    return failure(
+      input,
+      "local-json-parse-missing-text",
+      "json.parse requires a string text argument."
+    );
+  }
+  if (text.length > maxTextChars) {
+    return failure(
+      input,
+      "local-json-parse-text-too-large",
+      "json.parse text exceeds maxTextChars."
+    );
+  }
+  try {
+    const value = JSON.parse(text);
+    return Object.freeze({
+      kind: "result",
+      result: Object.freeze({
+        kind: "json",
+        value: Object.freeze({ toolName: "json.parse", value }),
+        summary: "parsed JSON"
+      }),
+      evidenceRefs: input.sourceRefs
+    });
+  } catch {
+    return failure(input, "local-json-parse-invalid-json", "json.parse received invalid JSON.");
+  }
+}
+function localTextConcat(input, maxTextChars) {
+  const parts = input.toolCall?.arguments?.parts;
+  if (!Array.isArray(parts)) {
+    return failure(input, "local-text-concat-missing-parts", "text.concat requires a parts array.");
+  }
+  const separator = input.toolCall?.arguments?.separator ?? "";
+  if (typeof separator !== "string") {
+    return failure(
+      input,
+      "local-text-concat-invalid-separator",
+      "text.concat separator must be a string."
+    );
+  }
+  const text = parts.map((part) => String(part)).join(separator);
+  if (text.length > maxTextChars) {
+    return failure(
+      input,
+      "local-text-concat-too-large",
+      "text.concat result exceeds maxTextChars."
+    );
+  }
+  return Object.freeze({
+    kind: "result",
+    result: Object.freeze({
+      kind: "text",
+      value: Object.freeze({ toolName: "text.concat", text }),
+      summary: text
+    }),
+    evidenceRefs: input.sourceRefs
+  });
+}
+function processConfig(opts) {
+  const workingDirectory = (0, import_node_path.resolve)(opts.workingDirectory ?? ".");
+  const allowedWorkingDirectories = Object.freeze(
+    (opts.allowedWorkingDirectories ?? [workingDirectory]).map((dir) => (0, import_node_path.resolve)(dir))
+  );
+  const allowed = normalizeAllowedCommands(opts.allowedCommands ?? []);
+  return {
+    allowedCommands: allowed.commands,
+    duplicateCommands: allowed.duplicates,
+    invalidCommands: allowed.invalids,
+    workingDirectory,
+    allowedWorkingDirectories,
+    baseEnv: Object.freeze({ ...opts.baseEnv ?? {} }),
+    allowedEnvKeys: new Set(opts.allowedEnvKeys ?? []),
+    timeoutMs: positiveFinite(opts.timeoutMs, 1e4),
+    maxOutputBytes: Math.max(1, nonNegativeFinite(opts.maxOutputBytes, 64 * 1024)),
+    maxSummaryChars: Math.max(1, nonNegativeFinite(opts.maxSummaryChars, 512))
+  };
+}
+function processArguments(input) {
+  const raw = input.toolCall?.arguments;
+  if (!isRecord2(raw) || typeof raw.command !== "string" || raw.command.length === 0) {
+    return void 0;
+  }
+  const rawArgs = raw.args === void 0 ? Object.freeze([]) : stringArray(raw.args);
+  if (rawArgs === void 0) return void 0;
+  if (raw.cwd !== void 0 && typeof raw.cwd !== "string") return void 0;
+  if (raw.input !== void 0 && typeof raw.input !== "string") return void 0;
+  const rawEnv = raw.env === void 0 ? void 0 : processArgumentEnv(raw.env);
+  if (raw.env !== void 0 && rawEnv === void 0) return void 0;
+  return {
+    command: raw.command,
+    args: rawArgs,
+    ...raw.cwd === void 0 ? {} : { cwd: raw.cwd },
+    ...rawEnv === void 0 ? {} : { env: rawEnv },
+    ...raw.input === void 0 ? {} : { input: raw.input }
+  };
+}
+function argsAllowed(command, args) {
+  if (command.allowArgs === true) return true;
+  if (typeof command.allowArgs === "function") return command.allowArgs(args);
+  if (command.allowArgs === void 0) return args.length === 0;
+  return arraysEqual(command.allowArgs, args);
+}
+function resolveProcessCwd(requestedCwd, command, config) {
+  const rawCwd = command.cwd ?? requestedCwd;
+  const cwd = rawCwd === void 0 ? config.workingDirectory : (0, import_node_path.isAbsolute)(rawCwd) ? (0, import_node_path.resolve)(rawCwd) : (0, import_node_path.resolve)(config.workingDirectory, rawCwd);
+  const realCwd = realpath(cwd);
+  if (realCwd === void 0) return void 0;
+  return config.allowedWorkingDirectories.some((allowed) => {
+    const realAllowed = realpath(allowed);
+    return realAllowed !== void 0 && isPathInside(realCwd, realAllowed);
+  }) ? cwd : void 0;
+}
+function processEnv(inputEnv, config) {
+  const env = { ...config.baseEnv };
+  for (const [key, value] of Object.entries(inputEnv ?? {})) {
+    if (!config.allowedEnvKeys.has(key)) return void 0;
+    if (value !== void 0) env[key] = String(value);
+  }
+  return Object.freeze(env);
+}
+function processArgumentEnv(value) {
+  if (!isRecord2(value)) return void 0;
+  const env = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (entry !== void 0 && typeof entry !== "string" && typeof entry !== "number" && typeof entry !== "boolean") {
+      return void 0;
+    }
+    env[key] = entry;
+  }
+  return Object.freeze(env);
+}
+function runProcessTool(input, allowed, args, cwd, env, config) {
+  const executable = allowed.executable ?? args.command;
+  const argv = Object.freeze([...allowed.fixedArgs ?? [], ...args.args]);
+  const result = (0, import_node_child_process.spawnSync)(executable, argv, {
+    cwd,
+    env,
+    input: args.input,
+    encoding: "buffer",
+    shell: false,
+    timeout: config.timeoutMs,
+    maxBuffer: config.maxOutputBytes + 1
+  });
+  const stdout = result.stdout ?? Buffer.alloc(0);
+  const stderr = result.stderr ?? Buffer.alloc(0);
+  const truncated = stdout.length + stderr.length > config.maxOutputBytes;
+  if (result.error !== void 0 && isTimeoutError(result.error)) {
+    return Object.freeze({
+      kind: "timeout",
+      timeoutMs: config.timeoutMs,
+      retryable: true,
+      evidenceRefs: input.sourceRefs
+    });
+  }
+  if (result.error !== void 0 || truncated) {
+    return failure(
+      input,
+      truncated || isOutputLimitError(result.error) ? "process-output-limit-exceeded" : "process-spawn-failed",
+      truncated || isOutputLimitError(result.error) ? "Process output exceeded maxOutputBytes." : "Process execution failed before producing an exit result."
+    );
+  }
+  const value = processResult(
+    args.command,
+    argv,
+    cwd,
+    result.status,
+    result.signal,
+    stdout,
+    stderr,
+    config
+  );
+  if ((result.status ?? 1) !== 0) {
+    return Object.freeze({
+      kind: "failure",
+      error: issue("process-exit-nonzero", "Process exited with a non-zero status.", "error", {
+        exitCode: result.status,
+        signal: result.signal ?? void 0
+      }),
+      retryable: false,
+      evidenceRefs: input.sourceRefs,
+      metadata: Object.freeze({
+        command: args.command,
+        exitCode: result.status,
+        signal: result.signal ?? void 0,
+        outputBytes: value.outputBytes,
+        errorOutputBytes: value.errorOutputBytes
+      })
+    });
+  }
+  return Object.freeze({
+    kind: "result",
+    result: Object.freeze({
+      kind: "process-result",
+      value,
+      summary: value.outputPreview ?? `process exited ${value.exitCode ?? 0}`,
+      artifacts: processArtifacts(stdout, stderr, config, input.sourceRefs)
+    }),
+    evidenceRefs: input.sourceRefs
+  });
+}
+function processResult(command, args, cwd, exitCode, signal, stdout, stderr, config) {
+  return Object.freeze({
+    command,
+    args,
+    cwd,
+    exitCode,
+    ...signal === null ? {} : { signal },
+    outputPreview: preview(stdout, config.maxSummaryChars),
+    errorPreview: preview(stderr, config.maxSummaryChars),
+    outputBytes: stdout.length,
+    errorOutputBytes: stderr.length,
+    truncated: false
+  });
+}
+function processArtifacts(stdout, stderr, config, sourceRefs) {
+  const artifacts = [
+    processTextArtifact("process-stdout", stdout, config, sourceRefs),
+    processTextArtifact("process-stderr", stderr, config, sourceRefs)
+  ].filter((artifact) => artifact !== void 0);
+  return artifacts.length === 0 ? void 0 : Object.freeze(artifacts);
+}
+function processTextArtifact(kind, bytes, config, sourceRefs) {
+  if (bytes.length === 0) return void 0;
+  const text = bytes.toString("utf8");
+  const inline = text.length <= config.maxSummaryChars;
+  return Object.freeze({
+    kind,
+    format: "text",
+    mediaType: "text/plain",
+    encoding: "utf8",
+    byteLength: bytes.length,
+    dataMode: inline ? "inline" : "summary",
+    summary: preview(bytes, config.maxSummaryChars),
+    ...inline ? { value: text } : {},
+    ...sourceRefs === void 0 ? {} : { sourceRefs },
+    sizeEvidence: Object.freeze([
+      sizeEvidence(bytes.length, "adapter-measured-process-output", sourceRefs)
+    ])
+  });
+}
+function processToolProviderExecutionPolicy(providerId, profileId, opts) {
+  const maxOutputBytes = Math.max(1, nonNegativeFinite(opts.maxOutputBytes, 64 * 1024));
+  return Object.freeze({
+    kind: "tool-provider-execution-policy",
+    policyId: `${providerId}:policy:process-v0`,
+    providerId,
+    profileIds: Object.freeze([profileId]),
+    toolNames: Object.freeze(["process.execFile"]),
+    operations: Object.freeze(["run"]),
+    sizeCapacity: Object.freeze({
+      limits: Object.freeze([
+        Object.freeze({
+          unit: "bytes",
+          hardLimit: maxOutputBytes,
+          perRequest: true,
+          measurementSource: "adapter-measured"
+        })
+      ])
+    }),
+    timeout: Object.freeze({ timeoutMs: positiveFinite(opts.timeoutMs, 1e4) }),
+    redaction: Object.freeze({
+      mode: "summary",
+      summaryMaxChars: nonNegativeFinite(opts.maxSummaryChars, 512)
+    }),
+    filesystem: Object.freeze({
+      cwd: opts.workingDirectory ?? ".",
+      allowRead: false,
+      allowWrite: false,
+      followSymlinks: false,
+      pathRules: Object.freeze(
+        (opts.allowedWorkingDirectories ?? [opts.workingDirectory ?? "."]).map(
+          (path) => Object.freeze({
+            effect: "allow",
+            path,
+            operation: "run",
+            reason: "Process adapter cwd allowlist."
+          })
+        )
+      )
+    }),
+    approval: Object.freeze({ mode: "auto" }),
+    metadata: Object.freeze({
+      argv: true,
+      shell: false,
+      allowedEnvKeys: Object.freeze([...opts.allowedEnvKeys ?? []])
+    })
+  });
+}
+function httpRuntimeConfig(opts) {
+  return {
+    allowedOrigins: new Set(opts.allowedOrigins ?? []),
+    allowedMethods: new Set(normalizeMethods(opts.allowedMethods ?? ["GET"])),
+    allowedRequestHeaders: new Set(normalizeHeaderNames(opts.allowedRequestHeaders ?? [])),
+    exposedResponseHeaders: new Set(normalizeHeaderNames(opts.exposedResponseHeaders ?? [])),
+    timeoutMs: positiveFinite(opts.timeoutMs, 1e4),
+    maxResponseBytes: Math.max(1, nonNegativeFinite(opts.maxResponseBytes, 64 * 1024)),
+    maxInlineBodyChars: Math.max(1, nonNegativeFinite(opts.maxInlineBodyChars, 4096)),
+    approvalMode: opts.approvalMode ?? "auto"
+  };
+}
+function httpToolProviderExecutionPolicy(providerId, profileId, opts) {
+  const allowedOrigins = Object.freeze([...opts.allowedOrigins ?? []]);
+  const allowedMethods = Object.freeze(normalizeMethods(opts.allowedMethods ?? ["GET"]));
+  const maxResponseBytes = Math.max(1, nonNegativeFinite(opts.maxResponseBytes, 64 * 1024));
+  return Object.freeze({
+    kind: "tool-provider-execution-policy",
+    policyId: `${providerId}:policy:http-v0`,
+    providerId,
+    profileIds: Object.freeze([profileId]),
+    toolNames: Object.freeze(["http.fetch"]),
+    operations: Object.freeze(["fetch"]),
+    sizeCapacity: Object.freeze({
+      limits: Object.freeze([
+        Object.freeze({
+          unit: "bytes",
+          hardLimit: maxResponseBytes,
+          perRequest: true,
+          measurementSource: "adapter-measured-response-body"
+        })
+      ])
+    }),
+    timeout: Object.freeze({ timeoutMs: positiveFinite(opts.timeoutMs, 1e4) }),
+    redaction: Object.freeze({
+      mode: "summary",
+      summaryMaxChars: nonNegativeFinite(opts.maxInlineBodyChars, 4096)
+    }),
+    network: Object.freeze({
+      mode: "allowlist",
+      protocols: Object.freeze(["http:", "https:"]),
+      allowedHosts: allowedOrigins,
+      metadata: Object.freeze({ allowlistKind: "origin" })
+    }),
+    approval: Object.freeze({ mode: opts.approvalMode ?? "auto" }),
+    artifacts: Object.freeze({
+      defaultDataMode: "summary",
+      inlineLimits: Object.freeze([
+        Object.freeze({
+          unit: "chars",
+          hardLimit: Math.max(1, nonNegativeFinite(opts.maxInlineBodyChars, 4096)),
+          perArtifact: true,
+          measurementSource: "js-string-length"
+        })
+      ]),
+      artifactKinds: Object.freeze(["http-response-body"])
+    }),
+    metadata: Object.freeze({
+      allowedOrigins,
+      allowedMethods,
+      allowedRequestHeaders: Object.freeze([...opts.allowedRequestHeaders ?? []]),
+      exposedResponseHeaders: Object.freeze([...opts.exposedResponseHeaders ?? []]),
+      asyncRuntime: true
+    })
+  });
+}
+function prepareHttpRequest(input, config) {
+  const raw = input.toolCall?.arguments;
+  if (!isRecord2(raw) || typeof raw.url !== "string") {
+    return {
+      kind: "blocked",
+      issue: issue("http-invalid-arguments", "http.fetch requires a string url argument.")
+    };
+  }
+  let url;
+  try {
+    url = new URL(raw.url);
+  } catch {
+    return { kind: "blocked", issue: issue("http-invalid-url", "http.fetch url is invalid.") };
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    return {
+      kind: "blocked",
+      issue: issue("http-protocol-not-allowed", "http.fetch only allows http and https URLs.")
+    };
+  }
+  if (!config.allowedOrigins.has(url.origin)) {
+    return {
+      kind: "blocked",
+      issue: issue("http-origin-not-allowed", "http.fetch origin is not allowlisted.")
+    };
+  }
+  const method = normalizeMethod(raw.method ?? "GET");
+  if (method === void 0 || !config.allowedMethods.has(method)) {
+    return {
+      kind: "blocked",
+      issue: issue("http-method-not-allowed", "http.fetch method is not allowlisted.")
+    };
+  }
+  if (raw.body !== void 0 && typeof raw.body !== "string") {
+    return {
+      kind: "blocked",
+      issue: issue("http-invalid-body", "http.fetch body must be a string when provided.")
+    };
+  }
+  const headers = httpArgumentHeaders(raw.headers, config);
+  if (headers === void 0) {
+    return {
+      kind: "blocked",
+      issue: issue("http-request-header-not-allowed", "http.fetch header is not allowlisted.")
+    };
+  }
+  return {
+    kind: "ready",
+    request: Object.freeze({
+      url: url.toString(),
+      method,
+      headers,
+      ...raw.body === void 0 ? {} : { body: raw.body }
+    })
+  };
+}
+function httpArgumentHeaders(value, config) {
+  if (value === void 0) return Object.freeze({});
+  if (!isRecord2(value)) return void 0;
+  const headers = {};
+  for (const [key, entry] of Object.entries(value)) {
+    const normalized = key.toLowerCase();
+    if (!config.allowedRequestHeaders.has(normalized)) return void 0;
+    if (entry !== void 0 && typeof entry !== "string" && typeof entry !== "number" && typeof entry !== "boolean") {
+      return void 0;
+    }
+    if (entry !== void 0) headers[key] = String(entry);
+  }
+  return Object.freeze(headers);
+}
+function httpResponseResult(request, response, config) {
+  const hasInlineBody = response.bodyText !== void 0;
+  const bodyText = response.bodyText ?? "";
+  const bodyBytes = response.bodyBytes ?? textBytes(bodyText);
+  const hasBodyRef = response.bodyRef !== void 0;
+  if (bodyBytes > config.maxResponseBytes && !hasBodyRef) {
+    return {
+      kind: "failure",
+      error: issue("http-response-too-large", "HTTP response body exceeded maxResponseBytes."),
+      retryable: false,
+      metadata: Object.freeze({ bodyBytes, maxResponseBytes: config.maxResponseBytes })
+    };
+  }
+  const inline = hasInlineBody && bodyBytes <= config.maxResponseBytes && bodyText.length <= config.maxInlineBodyChars;
+  const result = Object.freeze({
+    url: response.url ?? request.url,
+    method: request.method,
+    status: response.status,
+    statusText: response.statusText ?? "",
+    headers: filterResponseHeaders(response.headers, config.exposedResponseHeaders),
+    bodyPreview: hasInlineBody ? previewText(bodyText, config.maxInlineBodyChars) : void 0,
+    ...inline ? { bodyText } : {},
+    bodyBytes,
+    bodyTruncated: bodyBytes > config.maxResponseBytes || bodyText.length > config.maxInlineBodyChars,
+    dataMode: inline ? "inline" : hasBodyRef ? "ref" : "summary",
+    ...response.bodyRef === void 0 ? {} : { bodyRef: response.bodyRef }
+  });
+  return {
+    kind: "result",
+    result: Object.freeze({
+      kind: "http-result",
+      value: result,
+      summary: `${request.method} ${response.status} ${response.url ?? request.url}`,
+      refs: response.bodyRef === void 0 ? void 0 : Object.freeze([response.bodyRef]),
+      artifacts: Object.freeze([httpBodyArtifact(result, response.bodyRef)])
+    }),
+    issues: !inline && !hasBodyRef ? Object.freeze([
+      issue(
+        "http-response-body-summary-only",
+        "HTTP response body was summarized without a durable body ref.",
+        "warning"
+      )
+    ]) : void 0,
+    metadata: Object.freeze({ status: response.status, bodyBytes })
+  };
+}
+function httpBodyArtifact(result, bodyRef) {
+  return Object.freeze({
+    kind: "http-response-body",
+    format: "text",
+    byteLength: result.bodyBytes,
+    dataMode: result.dataMode,
+    ...result.bodyPreview === void 0 ? {} : { summary: result.bodyPreview },
+    ...result.dataMode === "inline" && result.bodyText !== void 0 ? { value: result.bodyText } : {},
+    ...bodyRef === void 0 ? {} : { ref: bodyRef, refs: Object.freeze([bodyRef]) },
+    sizeEvidence: Object.freeze([
+      sizeEvidence(result.bodyBytes, "adapter-measured-http-response-body", void 0)
+    ])
+  });
+}
+function httpErrorResult(error, config) {
+  const aborted = error instanceof Error && error.name === "AbortError";
+  if (aborted) {
+    return { kind: "timeout", timeoutMs: config.timeoutMs, retryable: true };
+  }
+  return {
+    kind: "failure",
+    error: issue("http-fetch-failed", "HTTP fetch failed before producing a response."),
+    retryable: true,
+    metadata: Object.freeze({ errorType: error instanceof Error ? error.name : typeof error })
+  };
+}
+function defaultHttpToolProviderDriver(maxResponseBytes) {
+  return Object.freeze({
+    fetch(request) {
+      const fetchImpl = globalThis.fetch;
+      if (typeof fetchImpl !== "function") {
+        throw new Error("global fetch is unavailable");
+      }
+      return fetchImpl(request.url, {
+        method: request.method,
+        headers: request.headers,
+        body: request.body,
+        redirect: "manual",
+        signal: request.signal
+      }).then(
+        (response) => readResponseBody(response, maxResponseBytes).then(
+          (body) => Object.freeze({
+            url: response.url,
+            status: response.status,
+            statusText: response.statusText,
+            headers: responseHeaders(response.headers),
+            bodyText: body.text,
+            bodyBytes: body.bytes
+          })
+        )
+      );
+    }
+  });
+}
+function readResponseBody(response, maxBytes) {
+  const body = response.body;
+  if (body === null) return Promise.resolve({ text: "", bytes: 0 });
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  const chunks = [];
+  let bytes = 0;
+  function pump() {
+    return reader.read().then((next) => {
+      if (next.done) {
+        chunks.push(decoder.decode());
+        return { text: chunks.join(""), bytes };
+      }
+      bytes += next.value.byteLength;
+      if (bytes > maxBytes) {
+        reader.cancel().catch(() => {
+        });
+        return { text: chunks.join(""), bytes };
+      }
+      chunks.push(decoder.decode(next.value, { stream: true }));
+      return pump();
+    });
+  }
+  return pump();
+}
+function responseHeaders(headers) {
+  const out = {};
+  headers.forEach((value, key) => {
+    out[key] = value;
+  });
+  return Object.freeze(out);
+}
+function filterResponseHeaders(headers, exposed) {
+  if (headers === void 0 || exposed.size === 0) return void 0;
+  const out = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (exposed.has(key.toLowerCase())) out[key] = value;
+  }
+  return Object.keys(out).length === 0 ? void 0 : Object.freeze(out);
+}
+function requestMatchesInput(request, input) {
+  return request.adapterInputId === input.adapterInputId && request.requestId === input.requestId && request.operationId === input.operationId && (request.routeId === void 0 || request.routeId === input.routeId) && (request.executorId === void 0 || request.executorId === input.executorId) && (request.profileId === void 0 || request.profileId === input.profileId);
+}
+function requestApproved(request) {
+  const metadata = request.metadata;
+  return isRecord2(metadata) && (metadata.approval === "granted" || metadata.approvalGranted === true || isAdmissionApprovedMetadata(metadata) && hasAdmissionSourceRef(request.sourceRefs));
+}
+function isAdmissionApprovedMetadata(metadata) {
+  return typeof metadata.admissionId === "string" && metadata.admissionId.length > 0 && typeof metadata.proposalId === "string" && metadata.proposalId.length > 0 && typeof metadata.approvedFromRunId === "string" && metadata.approvedFromRunId.length > 0;
+}
+function hasAdmissionSourceRef(sourceRefs) {
+  return (sourceRefs ?? []).some(
+    (sourceRef) => sourceRef.kind === "tool-provider-run-admission" || sourceRef.kind === "tool-provider-run-admission-decision"
+  );
+}
+function defaultEvidenceRefs(input) {
+  return Object.freeze([
+    { kind: "tool-provider-adapter-input", id: input.adapterInputId },
+    ...input.sourceRefs ?? []
+  ]);
+}
+function outcomeIssues(outcome) {
+  if (outcome.kind === "failure") return Object.freeze([outcome.error, ...outcome.issues ?? []]);
+  return outcome.issues ?? [];
+}
+function agentStatusForOutcome(outcome) {
+  switch (outcome.kind) {
+    case "result":
+      return "completed";
+    case "failure":
+      return "failed";
+    case "blocked":
+      return "blocked";
+    case "canceled":
+      return "canceled";
+    case "timeout":
+      return "timeout";
+  }
+}
+function normalizeMethods(methods) {
+  return Object.freeze(
+    methods.map((method) => normalizeMethod(method)).filter((method) => method !== void 0)
+  );
+}
+function normalizeMethod(method) {
+  return typeof method === "string" && method.length > 0 ? method.toUpperCase() : void 0;
+}
+function normalizeHeaderNames(headers) {
+  return Object.freeze(
+    headers.filter((header) => typeof header === "string" && header.length > 0).map((header) => header.toLowerCase())
+  );
+}
+function textBytes(text) {
+  return new TextEncoder().encode(text).byteLength;
+}
+function previewText(text, maxChars) {
+  if (text.length === 0) return void 0;
+  return text.length <= maxChars ? text : text.slice(0, maxChars);
+}
+function blocked(input, code, message) {
+  return Object.freeze({
+    kind: "blocked",
+    needs: Object.freeze([
+      Object.freeze({
+        kind: code,
+        message,
+        refs: input.providerId === void 0 ? void 0 : Object.freeze([{ kind: "tool-provider", id: input.providerId }])
+      })
+    ]),
+    issues: Object.freeze([issue(code, message, "error")]),
+    evidenceRefs: input.sourceRefs
+  });
+}
+function failure(input, code, message) {
+  return Object.freeze({
+    kind: "failure",
+    error: issue(code, message, "error"),
+    retryable: false,
+    evidenceRefs: input.sourceRefs
+  });
+}
+function issue(code, message, severity = "error", details) {
+  return Object.freeze({
+    kind: "issue",
+    code,
+    message,
+    severity,
+    ...details === void 0 ? {} : { details }
+  });
+}
+function sizeEvidence(quantity, measurementSource, sourceRefs) {
+  return Object.freeze({
+    kind: "size-capacity-evidence",
+    unit: "bytes",
+    quantity,
+    measurementSource,
+    ...sourceRefs === void 0 ? {} : { sourceRefs }
+  });
+}
+function nonNegativeFinite(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function positiveFinite(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const entries = Array.from(value);
+  if (!entries.every((entry) => typeof entry === "string")) return void 0;
+  return Object.freeze(entries);
+}
+function arraysEqual(a, b) {
+  return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+function normalizeAllowedCommands(commands) {
+  const out = /* @__PURE__ */ new Map();
+  const duplicates = /* @__PURE__ */ new Set();
+  const invalids = /* @__PURE__ */ new Set();
+  for (const command of commands) {
+    if (typeof command.command !== "string" || command.command.length === 0) {
+      invalids.add("<invalid-command>");
+      continue;
+    }
+    const frozen = freezeAllowedCommand(command);
+    if (frozen === void 0) {
+      out.delete(command.command);
+      invalids.add(command.command);
+      continue;
+    }
+    if (out.has(command.command)) {
+      out.delete(command.command);
+      duplicates.add(command.command);
+      continue;
+    }
+    if (duplicates.has(command.command) || invalids.has(command.command)) continue;
+    out.set(command.command, frozen);
+  }
+  return { commands: out, duplicates, invalids };
+}
+function freezeAllowedCommand(command) {
+  const fixedArgs = command.fixedArgs === void 0 ? void 0 : stringArray(command.fixedArgs);
+  if (command.fixedArgs !== void 0 && fixedArgs === void 0) return void 0;
+  const allowArgs = Array.isArray(command.allowArgs) ? stringArray(command.allowArgs) : command.allowArgs;
+  if (Array.isArray(command.allowArgs) && allowArgs === void 0) return void 0;
+  return Object.freeze({
+    command: command.command,
+    ...command.executable === void 0 ? {} : { executable: command.executable },
+    ...fixedArgs === void 0 ? {} : { fixedArgs },
+    ...allowArgs === void 0 ? {} : { allowArgs },
+    ...command.cwd === void 0 ? {} : { cwd: command.cwd }
+  });
+}
+function realpath(path) {
+  try {
+    return import_node_fs.realpathSync.native(path);
+  } catch {
+    return void 0;
+  }
+}
+function isPathInside(path, root) {
+  const normalizedPath = (0, import_node_path.resolve)(path);
+  const normalizedRoot = (0, import_node_path.resolve)(root);
+  const rel = (0, import_node_path.relative)(normalizedRoot, normalizedPath);
+  return rel === "" || rel.length > 0 && !rel.startsWith("..") && !(0, import_node_path.isAbsolute)(rel);
+}
+function isTimeoutError(error) {
+  return error.code === "ETIMEDOUT";
+}
+function isOutputLimitError(error) {
+  return error?.code === "ENOBUFS";
+}
+function preview(buffer, maxChars) {
+  if (buffer.length === 0) return void 0;
+  const text = buffer.toString("utf8");
+  return text.length <= maxChars ? text : text.slice(0, maxChars);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  httpToolProviderCatalog,
+  httpToolProviderRuntime,
+  localBuiltinToolProviderAdapterPack,
+  localBuiltinToolProviderBinding,
+  processToolProviderAdapterPack,
+  processToolProviderBinding,
+  processToolProviderCatalog
+});
+//# sourceMappingURL=tool-provider-adapters.cjs.map