@graphrefly/ts 0.0.1 → 0.0.2

package/dist/{chunk-2747WN4Y.js → chunk-TPND5MJS.js}

@@ -6,13 +6,13 @@ import {
   interval,
   of,
   timer
-} from "./chunk-V7CIJE4B.js";
+} from "./chunk-CX6B6PO2.js";
 import {
   filter,
   initNode,
   map,
   merge
-} from "./chunk-SS2A464I.js";
+} from "./chunk-CJIFGJQG.js";
 import {
   CTX_NODE_BINDING,
   depBatch,
@@ -459,4 +459,4 @@ export {
   timeout,
   bufferTime
 };
-//# sourceMappingURL=chunk-2747WN4Y.js.map
+//# sourceMappingURL=chunk-TPND5MJS.js.map

package/dist/chunk-TQPCAIQI.js

@@ -0,0 +1,612 @@
+import {
+  depBatch
+} from "./chunk-WQIA3GFB.js";
+
+// 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 forbiddenAdapterInputMaterialIssues(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-input-forbidden-runtime-material",
+        "Tool provider adapter input 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((issue) => sanitizeAdapterInputIssue(issue)))
+    },
+    ...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(issue, policy) {
+  const boundedMessage = boundPublicText(issue.message, maxPublicMessageChars(policy));
+  const details = sanitizeIssueDetails(issue.details, policy);
+  const metadata = sanitizeProviderGraphVisibleRecord(issue.metadata, policy);
+  const refs = issue.refs === void 0 ? void 0 : Object.freeze(issue.refs.filter((entry) => typeof entry === "string"));
+  return Object.freeze({
+    kind: issue.kind,
+    code: issue.code,
+    ...issue.source === void 0 ? {} : { source: issue.source },
+    message: boundedMessage.text,
+    severity: issue.severity,
+    subjectId: issue.subjectId,
+    ...issue.correlationId === void 0 ? {} : { correlationId: issue.correlationId },
+    ...issue.causationId === void 0 ? {} : { causationId: issue.causationId },
+    ...issue.path === void 0 ? {} : { path: Object.freeze([...issue.path]) },
+    ...refs === void 0 || refs.length === 0 ? {} : { refs },
+    ...issue.retryable === void 0 ? {} : { retryable: issue.retryable },
+    details: boundedMessage.truncated || details !== issue.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;
+}
+
+export {
+  uniqueSourceRefs,
+  stableJsonStringify,
+  stableStringHash,
+  cloneGraphVisibleMaterial,
+  projectRuntimeFact,
+  forEachDepBatch,
+  forbiddenDataKeys,
+  forbiddenGraphVisibleMaterialIssues,
+  forbiddenAdapterInputMaterialIssues,
+  sanitizeAdapterInputSourceRefs,
+  sanitizeGraphVisibleRecord,
+  sanitizeProviderGraphVisibleRecord,
+  canonicalPublicSourceRefs,
+  publicMaterialForbiddenKeys,
+  unlockedToolProviderPolicyOverrides,
+  sanitizeAgentOutputEnvelope,
+  sanitizeAgentNeed,
+  sanitizeRuntimeMetadata,
+  boundedPublicText,
+  boundPublicText,
+  maxPublicReasonChars,
+  maxPublicMetadataStringChars,
+  sanitizeAdapterInputIssue,
+  forbiddenProviderRawMaterialKeys,
+  dataIssue,
+  ref,
+  isRecord,
+  isPlainRecord
+};
+//# sourceMappingURL=chunk-TQPCAIQI.js.map