@adcp/sdk 15.4.0 → 15.5.0

package/dist/lib/protocols/transportDiagnostics.js

@@ -30,6 +30,7 @@ __export(transportDiagnostics_exports, {
 module.exports = __toCommonJS(transportDiagnostics_exports);
 var import_global_async_local_storage = require('../utils/global-async-local-storage.js');
 var import_node_crypto = require("node:crypto");
+var import_mcp_call_context = require('./mcp-call-context.js');
 const BODY_SNIPPET_LIMIT = 64 * 1024;
 const BODY_SNIPPET_TIMEOUT_MS = 1e3;
 const OBSERVER_FLUSH_TIMEOUT_MS = 5e3;
@@ -110,7 +111,7 @@ function wrapFetchWithTransportDiagnostics(upstream) {
     const url = sanitizeTransportUrl(getUrl(input));
     const requestHeaders = sanitizeTransportHeaders(mergeRequestHeaders(input, init));
     const requestBody = bodySnippet(init?.body);
-    const baseEvent = {
+    const correlation = {
       agentId: slot.agentId,
       protocol: slot.protocol,
       transportRequestId,
@@ -122,11 +123,15 @@ function wrapFetchWithTransportDiagnostics(upstream) {
       method,
       url,
       requestHeaders,
+      startedAt
+    };
+    const signal = getSignal(input, init);
+    const baseEvent = {
+      ...correlation,
       ...requestBody && {
         requestBody: requestBody.body,
         requestBodyTruncated: requestBody.truncated
-      },
-      startedAt
+      }
     };
     emitTransportActivity(handler, {
       type: "request_started",
@@ -148,13 +153,18 @@ function wrapFetchWithTransportDiagnostics(upstream) {
       };
       const responseBody = responseBodySnippet(response);
       if (!responseBody) {
-        emitTransportActivity(
-          handler,
-          response.body ? {
-            ...responseEvent,
-            responseBodyTruncated: true
-          } : responseEvent
-        );
+        if (!response.body) {
+          emitTransportActivity(handler, responseEvent);
+          return response;
+        }
+        const observer = observeResponseBody(response, handler, correlation, startedAtMs, signal);
+        emitTransportActivity(handler, {
+          ...responseEvent,
+          responseBodyTruncated: true,
+          ...observer && { streaming: true }
+        });
+        observer?.start();
+        return observer?.response ?? response;
       } else {
         void responseBody.then(
           (captured) => {
@@ -188,8 +198,13 @@ function wrapFetchWithTransportDiagnostics(upstream) {
   return wrapped;
 }
 function emitTransportActivity(handler, event) {
+  return dispatchTransportActivity(handler, event, true);
+}
+function emitUntrackedTransportActivity(handler, event) {
+  void dispatchTransportActivity(handler, event, false);
+}
+function dispatchTransportActivity(handler, event, track) {
   try {
-    const slot = transportDiagnosticsStorage.getStore();
     const frozen = Object.freeze(structuredClone(event));
     const pending = Promise.resolve().then(() => handler(frozen)).then(
       () => {
@@ -197,12 +212,113 @@ function emitTransportActivity(handler, event) {
       () => {
       }
     );
-    slot?.pending.push(pending);
+    if (track) transportDiagnosticsStorage.getStore()?.pending.push(pending);
     return pending;
   } catch {
     return void 0;
   }
 }
+function observeResponseBody(response, handler, correlation, startedAtMs, signal) {
+  const source = response.body;
+  if (!source) return void 0;
+  let reader;
+  try {
+    reader = source.getReader();
+  } catch {
+    return void 0;
+  }
+  const { status: httpStatus, statusText } = response;
+  let bytes = 0;
+  let finished = false;
+  const release = () => {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  };
+  const onAbort = () => finish((0, import_mcp_call_context.isMCPCallCompleted)(signal?.reason) ? "cancelled" : "aborted", signal?.reason);
+  const finish = (outcome, error) => {
+    if (finished) return;
+    finished = true;
+    signal?.removeEventListener("abort", onAbort);
+    try {
+      const resolved = outcome !== "ended" && signal?.aborted ? (0, import_mcp_call_context.isMCPCallCompleted)(signal.reason) ? "cancelled" : "aborted" : outcome;
+      const event = {
+        ...correlation,
+        type: "response_completed",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: Date.now() - startedAtMs,
+        httpStatus,
+        statusText,
+        outcome: resolved,
+        bytes
+      };
+      if (error !== void 0 && (resolved === "errored" || resolved === "aborted")) {
+        event.errorName = error instanceof Error ? error.name : typeof error;
+        event.errorMessage = sanitizeDiagnosticText(error instanceof Error ? error.message : String(error));
+      }
+      emitUntrackedTransportActivity(handler, event);
+    } catch {
+    }
+  };
+  const classify = (error) => error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError") ? "aborted" : "errored";
+  const stream = new ReadableStream(
+    {
+      async pull(controller) {
+        try {
+          const { done, value } = await reader.read();
+          if (done) {
+            finish("ended");
+            release();
+            controller.close();
+            return;
+          }
+          if (typeof value?.byteLength === "number") bytes += value.byteLength;
+          controller.enqueue(value);
+        } catch (error) {
+          finish(classify(error), error);
+          release();
+          throw error;
+        }
+      },
+      cancel(reason) {
+        finish("cancelled", reason);
+        return reader.cancel(reason).finally(release);
+      }
+    },
+    { highWaterMark: 0 }
+  );
+  let rebuilt;
+  try {
+    rebuilt = new Response(stream, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  } catch {
+    reader.releaseLock();
+    return void 0;
+  }
+  preserveResponseMetadata(response, rebuilt);
+  const start = () => {
+    reader.closed.catch((error) => finish(classify(error), error));
+    if (signal?.aborted) onAbort();
+    else signal?.addEventListener("abort", onAbort, { once: true });
+  };
+  return { response: rebuilt, start };
+}
+function preserveResponseMetadata(from, to) {
+  for (const key of ["url", "redirected", "type"]) {
+    try {
+      Object.defineProperty(to, key, { value: from[key], enumerable: true, configurable: true });
+    } catch {
+    }
+  }
+}
+function getSignal(input, init) {
+  if (init?.signal) return init.signal;
+  return input instanceof Request ? input.signal : void 0;
+}
 function getUrl(input) {
   return typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
 }

package/dist/lib/protocols/transportDiagnostics.mjs

@@ -5,6 +5,7 @@ const __dirname = __adcpDirname(__adcpFileURLToPath(import.meta.url));
 const require2 = __adcpCreateRequire(import.meta.url);
 import { globalAsyncLocalStorage } from "../utils/global-async-local-storage.mjs";
 import { createHmac, randomUUID } from "node:crypto";
+import { isMCPCallCompleted } from "./mcp-call-context.mjs";
 const BODY_SNIPPET_LIMIT = 64 * 1024;
 const BODY_SNIPPET_TIMEOUT_MS = 1e3;
 const OBSERVER_FLUSH_TIMEOUT_MS = 5e3;
@@ -85,7 +86,7 @@ function wrapFetchWithTransportDiagnostics(upstream) {
     const url = sanitizeTransportUrl(getUrl(input));
     const requestHeaders = sanitizeTransportHeaders(mergeRequestHeaders(input, init));
     const requestBody = bodySnippet(init?.body);
-    const baseEvent = {
+    const correlation = {
       agentId: slot.agentId,
       protocol: slot.protocol,
       transportRequestId,
@@ -97,11 +98,15 @@ function wrapFetchWithTransportDiagnostics(upstream) {
       method,
       url,
       requestHeaders,
+      startedAt
+    };
+    const signal = getSignal(input, init);
+    const baseEvent = {
+      ...correlation,
       ...requestBody && {
         requestBody: requestBody.body,
         requestBodyTruncated: requestBody.truncated
-      },
-      startedAt
+      }
     };
     emitTransportActivity(handler, {
       type: "request_started",
@@ -123,13 +128,18 @@ function wrapFetchWithTransportDiagnostics(upstream) {
       };
       const responseBody = responseBodySnippet(response);
       if (!responseBody) {
-        emitTransportActivity(
-          handler,
-          response.body ? {
-            ...responseEvent,
-            responseBodyTruncated: true
-          } : responseEvent
-        );
+        if (!response.body) {
+          emitTransportActivity(handler, responseEvent);
+          return response;
+        }
+        const observer = observeResponseBody(response, handler, correlation, startedAtMs, signal);
+        emitTransportActivity(handler, {
+          ...responseEvent,
+          responseBodyTruncated: true,
+          ...observer && { streaming: true }
+        });
+        observer?.start();
+        return observer?.response ?? response;
       } else {
         void responseBody.then(
           (captured) => {
@@ -163,8 +173,13 @@ function wrapFetchWithTransportDiagnostics(upstream) {
   return wrapped;
 }
 function emitTransportActivity(handler, event) {
+  return dispatchTransportActivity(handler, event, true);
+}
+function emitUntrackedTransportActivity(handler, event) {
+  void dispatchTransportActivity(handler, event, false);
+}
+function dispatchTransportActivity(handler, event, track) {
   try {
-    const slot = transportDiagnosticsStorage.getStore();
     const frozen = Object.freeze(structuredClone(event));
     const pending = Promise.resolve().then(() => handler(frozen)).then(
       () => {
@@ -172,12 +187,113 @@ function emitTransportActivity(handler, event) {
       () => {
       }
     );
-    slot?.pending.push(pending);
+    if (track) transportDiagnosticsStorage.getStore()?.pending.push(pending);
     return pending;
   } catch {
     return void 0;
   }
 }
+function observeResponseBody(response, handler, correlation, startedAtMs, signal) {
+  const source = response.body;
+  if (!source) return void 0;
+  let reader;
+  try {
+    reader = source.getReader();
+  } catch {
+    return void 0;
+  }
+  const { status: httpStatus, statusText } = response;
+  let bytes = 0;
+  let finished = false;
+  const release = () => {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  };
+  const onAbort = () => finish(isMCPCallCompleted(signal?.reason) ? "cancelled" : "aborted", signal?.reason);
+  const finish = (outcome, error) => {
+    if (finished) return;
+    finished = true;
+    signal?.removeEventListener("abort", onAbort);
+    try {
+      const resolved = outcome !== "ended" && signal?.aborted ? isMCPCallCompleted(signal.reason) ? "cancelled" : "aborted" : outcome;
+      const event = {
+        ...correlation,
+        type: "response_completed",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: Date.now() - startedAtMs,
+        httpStatus,
+        statusText,
+        outcome: resolved,
+        bytes
+      };
+      if (error !== void 0 && (resolved === "errored" || resolved === "aborted")) {
+        event.errorName = error instanceof Error ? error.name : typeof error;
+        event.errorMessage = sanitizeDiagnosticText(error instanceof Error ? error.message : String(error));
+      }
+      emitUntrackedTransportActivity(handler, event);
+    } catch {
+    }
+  };
+  const classify = (error) => error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError") ? "aborted" : "errored";
+  const stream = new ReadableStream(
+    {
+      async pull(controller) {
+        try {
+          const { done, value } = await reader.read();
+          if (done) {
+            finish("ended");
+            release();
+            controller.close();
+            return;
+          }
+          if (typeof value?.byteLength === "number") bytes += value.byteLength;
+          controller.enqueue(value);
+        } catch (error) {
+          finish(classify(error), error);
+          release();
+          throw error;
+        }
+      },
+      cancel(reason) {
+        finish("cancelled", reason);
+        return reader.cancel(reason).finally(release);
+      }
+    },
+    { highWaterMark: 0 }
+  );
+  let rebuilt;
+  try {
+    rebuilt = new Response(stream, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  } catch {
+    reader.releaseLock();
+    return void 0;
+  }
+  preserveResponseMetadata(response, rebuilt);
+  const start = () => {
+    reader.closed.catch((error) => finish(classify(error), error));
+    if (signal?.aborted) onAbort();
+    else signal?.addEventListener("abort", onAbort, { once: true });
+  };
+  return { response: rebuilt, start };
+}
+function preserveResponseMetadata(from, to) {
+  for (const key of ["url", "redirected", "type"]) {
+    try {
+      Object.defineProperty(to, key, { value: from[key], enumerable: true, configurable: true });
+    } catch {
+    }
+  }
+}
+function getSignal(input, init) {
+  if (init?.signal) return init.signal;
+  return input instanceof Request ? input.signal : void 0;
+}
 function getUrl(input) {
   return typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
 }

package/dist/lib/reporting/gcs/index.d.mts

@@ -5,3 +5,5 @@ export { createGcsReportingResourceReaderV1, createGcsReportingReferenceResolver
 export type { GcsReportingReadScopeV1, GcsReportingReadAuthorizationV1, GcsReportingReaderOptionsV1 } from './reader.mjs';
 export { createGcsReportingManagedDeliveryAdapterV1 } from './adapter.mjs';
 export type { CreateGcsReportingManagedDeliveryAdapterOptionsV1 } from './adapter.mjs';
+export { createGcsReportingRowObjectProviderV1 } from './row-provider.mjs';
+export type { CreateGcsReportingRowObjectProviderOptionsV1 } from './row-provider.mjs';

package/dist/lib/reporting/gcs/index.d.ts

@@ -5,3 +5,5 @@ export { createGcsReportingResourceReaderV1, createGcsReportingReferenceResolver
 export type { GcsReportingReadScopeV1, GcsReportingReadAuthorizationV1, GcsReportingReaderOptionsV1 } from './reader';
 export { createGcsReportingManagedDeliveryAdapterV1 } from './adapter';
 export type { CreateGcsReportingManagedDeliveryAdapterOptionsV1 } from './adapter';
+export { createGcsReportingRowObjectProviderV1 } from './row-provider';
+export type { CreateGcsReportingRowObjectProviderOptionsV1 } from './row-provider';

package/dist/lib/reporting/gcs/index.js

@@ -23,6 +23,7 @@ __export(gcs_exports, {
   createGcsReportingObjectFenceV1: () => import_fence.createGcsReportingObjectFenceV1,
   createGcsReportingReferenceResolverV1: () => import_reader.createGcsReportingReferenceResolverV1,
   createGcsReportingResourceReaderV1: () => import_reader.createGcsReportingResourceReaderV1,
+  createGcsReportingRowObjectProviderV1: () => import_row_provider.createGcsReportingRowObjectProviderV1,
   isReportingGcsFenceError: () => import_errors.isReportingGcsFenceError
 });
 module.exports = __toCommonJS(gcs_exports);
@@ -30,6 +31,7 @@ var import_fence = require('./fence.js');
 var import_errors = require('./errors.js');
 var import_reader = require('./reader.js');
 var import_adapter = require('./adapter.js');
+var import_row_provider = require('./row-provider.js');
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ReportingGcsFenceError,
@@ -37,5 +39,6 @@ var import_adapter = require('./adapter.js');
   createGcsReportingObjectFenceV1,
   createGcsReportingReferenceResolverV1,
   createGcsReportingResourceReaderV1,
+  createGcsReportingRowObjectProviderV1,
   isReportingGcsFenceError
 });

package/dist/lib/reporting/gcs/index.mjs

@@ -2,11 +2,13 @@ import { createGcsReportingObjectFenceV1 } from "./fence.mjs";
 import { ReportingGcsFenceError, isReportingGcsFenceError } from "./errors.mjs";
 import { createGcsReportingResourceReaderV1, createGcsReportingReferenceResolverV1 } from "./reader.mjs";
 import { createGcsReportingManagedDeliveryAdapterV1 } from "./adapter.mjs";
+import { createGcsReportingRowObjectProviderV1 } from "./row-provider.mjs";
 export {
   ReportingGcsFenceError,
   createGcsReportingManagedDeliveryAdapterV1,
   createGcsReportingObjectFenceV1,
   createGcsReportingReferenceResolverV1,
   createGcsReportingResourceReaderV1,
+  createGcsReportingRowObjectProviderV1,
   isReportingGcsFenceError
 };

package/dist/lib/reporting/gcs/row-provider.d.mts

@@ -0,0 +1,32 @@
+import type { BucketMetadata, Storage } from '@google-cloud/storage';
+import type { ReportingRowObjectProviderV1 } from '../ledger/row-storage-object.mjs';
+export interface CreateGcsReportingRowObjectProviderOptionsV1 {
+    /** Official client used by bindings without a `credentialRef`. */
+    storage?: Storage;
+    /**
+     * Official clients keyed by `credentialRef`. This map is the closed set of
+     * references a binding may name; an unknown reference fails `UNSAFE_BINDING`.
+     */
+    clients?: Readonly<Record<string, Storage>>;
+}
+/**
+ * Row-binding bucket policy (shared persistence spec §3.4). Unlike the Managed
+ * Delivery probe, versioning, soft delete and retention are allowed as
+ * backstops. Refused: buckets without uniform bucket-level access or enforced
+ * public access prevention, and any lifecycle `Delete` rule that can match a
+ * live object under the binding prefix (no prefix filter, or a prefix that
+ * overlaps it). Rules limited to noncurrent versions are allowed.
+ */
+export declare function assertGcsReportingRowBucketPolicyV1(metadata: BucketMetadata, prefix: string): void;
+/**
+ * Google Cloud Storage row-object provider (`@adcp/sdk/reporting/gcs`).
+ *
+ * Inject official `Storage` clients with host-owned, keyless credentials.
+ * Bindings use `location: { bucket }`; `credentialRef` selects an injected
+ * client. Writes are single-request uploads with `ifGenerationMatch: 0`, so an
+ * existing object is never replaced; the recorded native version is the
+ * object generation, and reads and deletes pin it. Objects are stored without
+ * `Content-Encoding`, and reads request raw stored bytes, so GCS never
+ * transcodes them.
+ */
+export declare function createGcsReportingRowObjectProviderV1(options: CreateGcsReportingRowObjectProviderOptionsV1): ReportingRowObjectProviderV1;

package/dist/lib/reporting/gcs/row-provider.d.ts

@@ -0,0 +1,32 @@
+import type { BucketMetadata, Storage } from '@google-cloud/storage';
+import type { ReportingRowObjectProviderV1 } from '../ledger/row-storage-object';
+export interface CreateGcsReportingRowObjectProviderOptionsV1 {
+    /** Official client used by bindings without a `credentialRef`. */
+    storage?: Storage;
+    /**
+     * Official clients keyed by `credentialRef`. This map is the closed set of
+     * references a binding may name; an unknown reference fails `UNSAFE_BINDING`.
+     */
+    clients?: Readonly<Record<string, Storage>>;
+}
+/**
+ * Row-binding bucket policy (shared persistence spec §3.4). Unlike the Managed
+ * Delivery probe, versioning, soft delete and retention are allowed as
+ * backstops. Refused: buckets without uniform bucket-level access or enforced
+ * public access prevention, and any lifecycle `Delete` rule that can match a
+ * live object under the binding prefix (no prefix filter, or a prefix that
+ * overlaps it). Rules limited to noncurrent versions are allowed.
+ */
+export declare function assertGcsReportingRowBucketPolicyV1(metadata: BucketMetadata, prefix: string): void;
+/**
+ * Google Cloud Storage row-object provider (`@adcp/sdk/reporting/gcs`).
+ *
+ * Inject official `Storage` clients with host-owned, keyless credentials.
+ * Bindings use `location: { bucket }`; `credentialRef` selects an injected
+ * client. Writes are single-request uploads with `ifGenerationMatch: 0`, so an
+ * existing object is never replaced; the recorded native version is the
+ * object generation, and reads and deletes pin it. Objects are stored without
+ * `Content-Encoding`, and reads request raw stored bytes, so GCS never
+ * transcodes them.
+ */
+export declare function createGcsReportingRowObjectProviderV1(options: CreateGcsReportingRowObjectProviderOptionsV1): ReportingRowObjectProviderV1;