@graphrefly/ts 0.0.1 → 0.0.2

package/dist/chunk-7GOTIIQ7.js

@@ -0,0 +1,819 @@
+import {
+  boundPublicText,
+  boundedPublicText,
+  dataIssue,
+  forEachDepBatch,
+  forbiddenDataKeys,
+  forbiddenProviderRawMaterialKeys,
+  isRecord,
+  maxPublicReasonChars,
+  projectRuntimeFact,
+  publicMaterialForbiddenKeys,
+  ref,
+  sanitizeAdapterInputIssue,
+  sanitizeAdapterInputSourceRefs,
+  sanitizeAgentNeed,
+  sanitizeAgentOutputEnvelope,
+  sanitizeGraphVisibleRecord,
+  sanitizeProviderGraphVisibleRecord,
+  sanitizeRuntimeMetadata,
+  stableJsonStringify,
+  stableStringHash
+} from "./chunk-TQPCAIQI.js";
+import {
+  depBatch
+} from "./chunk-WQIA3GFB.js";
+
+// src/orchestration/agent-runtime-adapter-run.ts
+function normalizeToolProviderAdapterBindings(bindings) {
+  const result = /* @__PURE__ */ new Map();
+  const bindingList = Array.isArray(bindings) ? bindings : void 0;
+  if (bindingList === void 0) {
+    const bindingMap = bindings;
+    for (const [providerId, binding] of bindingMap.entries()) {
+      if (providerId !== binding.providerId) {
+        throw new RangeError(
+          `attachToolProviderAdapterRuntime: binding key '${providerId}' must match provider '${binding.providerId}'`
+        );
+      }
+      result.set(providerId, binding);
+    }
+    return result;
+  }
+  for (const binding of bindingList) {
+    if (result.has(binding.providerId)) {
+      throw new RangeError(
+        `attachToolProviderAdapterRuntime: duplicate binding for provider '${binding.providerId}'`
+      );
+    }
+    result.set(binding.providerId, binding);
+  }
+  return result;
+}
+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 issue = 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, issue, 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: [issue],
+              sourceRefs: request2.sourceRefs
+            },
+            opts.privateRetentionHooks
+          );
+          emitRunAudit(ctx, state, "tool-provider-adapter-run-request-invalid-shape", request2, {
+            issueCode: issue.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 issue = 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, issue, 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: [issue],
+              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 issue of issues)
+            emitRunIssueFact(ctx, state, issue, 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((issue) => issue.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((issue) => sanitizeAdapterInputIssue(issue)));
+  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, issue, privateRetentionHooks) {
+  const key = stableJsonStringify({
+    code: issue.code,
+    subjectId: issue.subjectId,
+    refs: issue.refs ?? [],
+    details: issue.details
+  });
+  if (state.issueKeys.has(key)) return;
+  state.issueKeys.add(key);
+  ctx.down([["DATA", { kind: "issue", issue }]]);
+  privateRetentionHooks?.onRunIssueKey?.({
+    key,
+    issue,
+    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((issue2) => sanitizeAdapterInputIssue(issue2, 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(
+    (issue2) => issue2.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 issue = 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: issue,
+    retryable: false,
+    issues: allLeakIssues
+  });
+}
+function agentRequestStatusForExecutorOutcome(outcome) {
+  switch (outcome.kind) {
+    case "result":
+      return "completed";
+    case "failure":
+      return "failed";
+    case "canceled":
+      return "canceled";
+    case "timeout":
+      return "timeout";
+    case "blocked":
+      return "blocked";
+  }
+}
+function toolProviderOutcomeRunSegment(runId, attempt) {
+  return runId === void 0 ? `attempt-${attempt}` : `${runId}:attempt-${attempt}`;
+}
+function adapterRuntimeIssue(input, code, error) {
+  return dataIssue(code, "Tool provider adapter runtime failed.", {
+    subjectId: input.requestId,
+    refs: [ref("tool-provider-adapter-input", input.adapterInputId)],
+    details: { errorType: error instanceof Error ? error.name : typeof error }
+  });
+}
+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 } }
+      )
+    )
+  );
+}
+function outcomeIssues(outcome) {
+  if (outcome.kind === "failure") return Object.freeze([outcome.error, ...outcome.issues ?? []]);
+  return outcome.issues ?? [];
+}
+
+export {
+  normalizeToolProviderAdapterBindings,
+  requestToolProviderAdapterRun,
+  toolProviderAdapterRunProjector,
+  toolProviderAdapterRunProjectorInternal,
+  runRequestIdentityIssues,
+  defaultToolProviderAdapterEvidenceRefs,
+  buildToolProviderExecutorOutcome,
+  agentRequestStatusForExecutorOutcome,
+  adapterRuntimeIssue,
+  outcomeIssues
+};
+//# sourceMappingURL=chunk-7GOTIIQ7.js.map