agentfootprint 2.8.0 → 2.8.2

package/dist/observability-providers.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * agentfootprint/observability-providers — vendor observability strategies.
+ *
+ * Grouped subpath following the parallel-providers pattern v2.5
+ * established for `llm-providers` / `tool-providers` /
+ * `memory-providers`. Adding a new vendor adds an export here, NOT
+ * a new subpath — keeps `package.json#exports` from sprawling.
+ *
+ * Each adapter lazy-imports its vendor SDK via `lib/lazyRequire.ts`,
+ * so consumers who never call a particular factory don't have to
+ * install that SDK. Peer-deps are declared in package.json with
+ * `peerDependenciesMeta.{name}.optional = true`.
+ *
+ * @example
+ * ```ts
+ * import { agentcoreObservability } from 'agentfootprint/observability-providers';
+ * import { microtaskBatchDriver } from 'footprintjs/detach';
+ *
+ * agent.enable.observability({
+ *   strategy: agentcoreObservability({
+ *     region: 'us-east-1',
+ *     logGroupName: '/agentfootprint/my-agent',
+ *   }),
+ *   // Recommended — keeps the agent loop unblocked by network latency.
+ *   detach: { driver: microtaskBatchDriver, mode: 'forget' },
+ * });
+ * ```
+ *
+ * Roadmap:
+ *   - agentcoreObservability   ← v2.8.1
+ *   - cloudwatchObservability  ← v2.8.2 (this release)
+ *   - xrayObservability        ← v2.8.3
+ *   - otelObservability        ← v2.9.x
+ *   - datadogObservability     ← v2.9.x
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloudwatchObservability = exports.agentcoreObservability = void 0;
+var agentcore_js_1 = require("./adapters/observability/agentcore.js");
+Object.defineProperty(exports, "agentcoreObservability", { enumerable: true, get: function () { return agentcore_js_1.agentcoreObservability; } });
+var cloudwatch_js_1 = require("./adapters/observability/cloudwatch.js");
+Object.defineProperty(exports, "cloudwatchObservability", { enumerable: true, get: function () { return cloudwatch_js_1.cloudwatchObservability; } });
+//# sourceMappingURL=observability-providers.js.map

package/dist/observability-providers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observability-providers.js","sourceRoot":"","sources":["../src/observability-providers.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;;;AAEH,sEAG+C;AAF7C,sHAAA,sBAAsB,OAAA;AAGxB,wEAGgD;AAF9C,wHAAA,uBAAuB,OAAA"}

package/dist/strategies/index.js

@@ -8,14 +8,28 @@
  *   - `types.ts` — typed interfaces (Observability, Cost, LiveStatus, Lens)
  *   - `defaults/` — the 4 in-core default strategies
  *
- * Vendor strategies ship as separate subpaths:
- *   - `agentfootprint/observability-agentcore` (v2.8.1)
- *   - `agentfootprint/observability-cloudwatch` (v2.8.2)
- *   - `agentfootprint/observability-xray` (v2.8.3)
- *   - `agentfootprint/observability-otel` (v2.9.x)
- *   - `agentfootprint/observability-datadog` (v2.9.x)
- *   - `agentfootprint/cost-stripe` (v2.10.x)
- *   - `agentfootprint/lens-browser` / `lens-cli` (v2.12.x)
+ * Vendor strategies ship under three GROUPED subpaths (matching the
+ * parallel-providers pattern v2.5 established for `llm-providers` /
+ * `tool-providers` / `memory-providers`). Each subpath holds N
+ * vendor-named factories — adding a vendor never adds a new subpath:
+ *
+ *   - `agentfootprint/observability-providers`
+ *       agentcoreObservability (v2.8.1)
+ *       cloudwatchObservability (v2.8.2)
+ *       xrayObservability (v2.8.3)
+ *       otelObservability (v2.9.x)
+ *       datadogObservability (v2.9.x)
+ *
+ *   - `agentfootprint/cost-providers`
+ *       stripeCost (v2.10.x)
+ *
+ *   - `agentfootprint/lens-providers`
+ *       browserLens / cliLens (v2.12.x)
+ *
+ * Each adapter lazy-imports its vendor SDK via `lib/lazyRequire.ts`,
+ * so consumers who never call a particular factory don't have to
+ * install that SDK. Peer-deps are declared in package.json with
+ * `peerDependenciesMeta.{name}.optional = true`.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;

package/dist/strategies/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/strategies/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;GAiBG;;;;;;;;;;;;;;;;;AAEH,6CAA2B;AAC3B,sDAAoC;AACpC,2CAAiG;AAAxF,kHAAA,oBAAoB,OAAA;AAAE,yGAAA,WAAW,OAAA;AAAE,+GAAA,iBAAiB,OAAA;AAAE,yGAAA,WAAW,OAAA;AAC1E,yCAOqB;AANnB,wHAAA,2BAA2B,OAAA;AAC3B,+GAAA,kBAAkB,OAAA;AAClB,qHAAA,wBAAwB,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/strategies/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;;;;;;;;;;;;;;;;;AAEH,6CAA2B;AAC3B,sDAAoC;AACpC,2CAAiG;AAAxF,kHAAA,oBAAoB,OAAA;AAAE,yGAAA,WAAW,OAAA;AAAE,+GAAA,iBAAiB,OAAA;AAAE,yGAAA,WAAW,OAAA;AAC1E,yCAOqB;AANnB,wHAAA,2BAA2B,OAAA;AAC3B,+GAAA,kBAAkB,OAAA;AAClB,qHAAA,wBAAwB,OAAA"}

package/dist/types/adapters/observability/agentcore.d.ts

@@ -0,0 +1,67 @@
+/**
+ * agentcoreObservability — AWS Bedrock AgentCore observability adapter.
+ *
+ * Ships every `AgentfootprintEvent` to **CloudWatch Logs** in a
+ * structured-JSON shape AgentCore's hosted-agent telemetry layer
+ * understands. Use when:
+ *
+ *   1. Your agent runs INSIDE AgentCore — events show up alongside
+ *      AgentCore's own runtime telemetry in the same log group.
+ *   2. Your agent runs OUTSIDE AgentCore but you want to query agent
+ *      behavior in CloudWatch Insights / X-Ray traces using the same
+ *      schema AgentCore uses internally.
+ *
+ * Subpath:  `agentfootprint/observability-providers`
+ * Peer dep: `@aws-sdk/client-cloudwatch-logs` (OPTIONAL — installed
+ *           only when this adapter is used; declared via
+ *           `peerDependenciesMeta.{name}.optional = true`).
+ *
+ * **Implementation:** thin wrapper over `cloudwatchObservability`'s
+ * shared base. The only difference is the strategy `name` (used for
+ * registry lookup + diagnostics). All batching, flush, error-routing,
+ * and SDK-loading behavior is identical. As we evolve the CloudWatch
+ * shipping path (retry, sequence tokens, metrics emission), every
+ * CloudWatch-shaped adapter inherits the improvement.
+ *
+ * @example Basic
+ * ```ts
+ * import { agentcoreObservability } from 'agentfootprint/observability-providers';
+ * import { microtaskBatchDriver } from 'footprintjs/detach';
+ *
+ * agent.enable.observability({
+ *   strategy: agentcoreObservability({
+ *     region: 'us-east-1',
+ *     logGroupName: '/agentfootprint/my-agent',
+ *     logStreamName: `${process.env.HOSTNAME}/${Date.now()}`,
+ *   }),
+ *   detach: { driver: microtaskBatchDriver, mode: 'forget' },
+ * });
+ * ```
+ *
+ * @example Test injection (skip SDK require entirely)
+ * ```ts
+ * agentcoreObservability({
+ *   _client: {
+ *     putLogEvents: async (input) => { capturedBatches.push(input); },
+ *   },
+ * });
+ * ```
+ */
+import type { ObservabilityStrategy } from '../../strategies/types.js';
+import { type CloudwatchObservabilityOptions } from './cloudwatch.js';
+/**
+ * AgentCore-specific options. Currently identical to the generic
+ * `CloudwatchObservabilityOptions` — kept as a separate type for
+ * future-proofing (AgentCore-specific knobs like
+ * `agentcoreSessionId` propagation could land here without a
+ * breaking change).
+ */
+export type AgentcoreObservabilityOptions = CloudwatchObservabilityOptions;
+/**
+ * Build an AgentCore-flavored CloudWatch Logs observability strategy.
+ * Functionally identical to `cloudwatchObservability` except for the
+ * strategy `name`, which lets registry-lookup + diagnostics
+ * distinguish AgentCore-targeted shipping from generic CloudWatch.
+ */
+export declare function agentcoreObservability(opts: AgentcoreObservabilityOptions): ObservabilityStrategy;
+//# sourceMappingURL=agentcore.d.ts.map

package/dist/types/adapters/observability/agentcore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentcore.d.ts","sourceRoot":"","sources":["../../../../src/adapters/observability/agentcore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAEvE,OAAO,EAEL,KAAK,8BAA8B,EACpC,MAAM,iBAAiB,CAAC;AAEzB;;;;;;GAMG;AACH,MAAM,MAAM,6BAA6B,GAAG,8BAA8B,CAAC;AAE3E;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,6BAA6B,GAAG,qBAAqB,CAEjG"}

package/dist/types/adapters/observability/cloudwatch.d.ts

@@ -0,0 +1,97 @@
+/**
+ * cloudwatchObservability — Generic AWS CloudWatch Logs adapter.
+ *
+ * Ships every `AgentfootprintEvent` to a CloudWatch Logs stream. Use
+ * when you want agent telemetry alongside the rest of your AWS
+ * observability stack — CloudWatch Insights queries, alarms,
+ * cross-service correlation. Same SDK as `agentcoreObservability`
+ * but **without** the AgentCore-specific defaults (log-stream
+ * convention, format opinions). Use this when:
+ *
+ *   1. You're shipping to CloudWatch but NOT running inside Bedrock
+ *      AgentCore (most common case).
+ *   2. You want full control over log group / stream / format and
+ *      don't need AgentCore's hosted-agent telemetry conventions.
+ *
+ * Subpath:  `agentfootprint/observability-providers`
+ * Peer dep: `@aws-sdk/client-cloudwatch-logs` (OPTIONAL — installed
+ *           only when this adapter is used; declared via
+ *           `peerDependenciesMeta.{name}.optional = true`).
+ *
+ * This module also exports the underlying base function used by
+ * `agentcoreObservability` — keeps the per-event hot path in one
+ * place so improvements (batching, retry, backpressure) flow to
+ * every CloudWatch-shaped adapter automatically.
+ *
+ * @example
+ * ```ts
+ * import { cloudwatchObservability } from 'agentfootprint/observability-providers';
+ * import { microtaskBatchDriver } from 'footprintjs/detach';
+ *
+ * agent.enable.observability({
+ *   strategy: cloudwatchObservability({
+ *     region: 'us-east-1',
+ *     logGroupName: '/myapp/agent-prod',
+ *     logStreamName: `${process.env.HOSTNAME}/${Date.now()}`,
+ *   }),
+ *   detach: { driver: microtaskBatchDriver, mode: 'forget' },
+ * });
+ * ```
+ */
+import type { ObservabilityStrategy } from '../../strategies/types.js';
+export interface CloudwatchObservabilityOptions {
+    /** AWS region. Falls back to AWS_REGION / AWS_DEFAULT_REGION env. */
+    readonly region?: string;
+    /** CloudWatch Logs log group. **Required.** Must exist or your IAM
+     *  role must allow `logs:CreateLogGroup`. */
+    readonly logGroupName: string;
+    /** CloudWatch Logs log stream within the group. Conventionally
+     *  `<host>/<startTime>` so multi-instance deployments don't
+     *  collide. Created on first put if it doesn't exist (or your
+     *  role must allow `logs:CreateLogStream`). Defaults to
+     *  `agentfootprint`. */
+    readonly logStreamName?: string;
+    /** Max events buffered before forced flush. Default 100. */
+    readonly maxBatchEvents?: number;
+    /** Max payload bytes (UTF-8) buffered before forced flush. Default
+     *  10240 (10 KB). CloudWatch hard caps at 1 MB / batch but we keep
+     *  the default low so latency stays bounded. */
+    readonly maxBatchBytes?: number;
+    /** Forced-flush interval when traffic is sparse. Default 1000ms.
+     *  `0` disables time-based flush — only size triggers fire. */
+    readonly flushIntervalMs?: number;
+    /** Test injection — bypasses SDK lazy-require entirely. When set,
+     *  `region` / IAM are ignored. */
+    readonly _client?: CloudWatchLikeClient;
+}
+export interface CloudWatchLikeClient {
+    putLogEvents(input: {
+        logGroupName: string;
+        logStreamName: string;
+        logEvents: ReadonlyArray<{
+            timestamp: number;
+            message: string;
+        }>;
+    }): Promise<unknown>;
+}
+/**
+ * Internal: shared CloudWatch Logs base used by every adapter that
+ * ships to CWL. `cloudwatchObservability` is the public generic
+ * factory; `agentcoreObservability` calls this with AgentCore-flavored
+ * defaults.
+ *
+ * Exported for adapter authors only — consumers should call
+ * `cloudwatchObservability` or `agentcoreObservability` directly.
+ *
+ * @internal
+ */
+export declare function _buildCloudWatchObservability(opts: CloudwatchObservabilityOptions, strategyName: string): ObservabilityStrategy;
+/**
+ * Generic CloudWatch Logs observability adapter. See
+ * `CloudwatchObservabilityOptions` for the per-option contract.
+ *
+ * For AgentCore-specific conventions, use `agentcoreObservability`
+ * which thin-wraps this with AgentCore-flavored defaults.
+ */
+export declare function cloudwatchObservability(opts: CloudwatchObservabilityOptions): ObservabilityStrategy;
+//# sourceMappingURL=cloudwatch.d.ts.map

package/dist/types/adapters/observability/cloudwatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudwatch.d.ts","sourceRoot":"","sources":["../../../../src/adapters/observability/cloudwatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAIH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAIvE,MAAM,WAAW,8BAA8B;IAC7C,qEAAqE;IACrE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;iDAC6C;IAC7C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;;4BAIwB;IACxB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,4DAA4D;IAC5D,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC;;oDAEgD;IAChD,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC;mEAC+D;IAC/D,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC;sCACkC;IAClC,QAAQ,CAAC,OAAO,CAAC,EAAE,oBAAoB,CAAC;CACzC;AAID,MAAM,WAAW,oBAAoB;IACnC,YAAY,CAAC,KAAK,EAAE;QAClB,YAAY,EAAE,MAAM,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;QACtB,SAAS,EAAE,aAAa,CAAC;YAAE,SAAS,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KAClE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACtB;AAUD;;;;;;;;;;GAUG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,8BAA8B,EACpC,YAAY,EAAE,MAAM,GACnB,qBAAqB,CA8GvB;AAID;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,8BAA8B,GACnC,qBAAqB,CAEvB"}

package/dist/types/observability-providers.d.ts

@@ -0,0 +1,38 @@
+/**
+ * agentfootprint/observability-providers — vendor observability strategies.
+ *
+ * Grouped subpath following the parallel-providers pattern v2.5
+ * established for `llm-providers` / `tool-providers` /
+ * `memory-providers`. Adding a new vendor adds an export here, NOT
+ * a new subpath — keeps `package.json#exports` from sprawling.
+ *
+ * Each adapter lazy-imports its vendor SDK via `lib/lazyRequire.ts`,
+ * so consumers who never call a particular factory don't have to
+ * install that SDK. Peer-deps are declared in package.json with
+ * `peerDependenciesMeta.{name}.optional = true`.
+ *
+ * @example
+ * ```ts
+ * import { agentcoreObservability } from 'agentfootprint/observability-providers';
+ * import { microtaskBatchDriver } from 'footprintjs/detach';
+ *
+ * agent.enable.observability({
+ *   strategy: agentcoreObservability({
+ *     region: 'us-east-1',
+ *     logGroupName: '/agentfootprint/my-agent',
+ *   }),
+ *   // Recommended — keeps the agent loop unblocked by network latency.
+ *   detach: { driver: microtaskBatchDriver, mode: 'forget' },
+ * });
+ * ```
+ *
+ * Roadmap:
+ *   - agentcoreObservability   ← v2.8.1
+ *   - cloudwatchObservability  ← v2.8.2 (this release)
+ *   - xrayObservability        ← v2.8.3
+ *   - otelObservability        ← v2.9.x
+ *   - datadogObservability     ← v2.9.x
+ */
+export { agentcoreObservability, type AgentcoreObservabilityOptions, } from './adapters/observability/agentcore.js';
+export { cloudwatchObservability, type CloudwatchObservabilityOptions, } from './adapters/observability/cloudwatch.js';
+//# sourceMappingURL=observability-providers.d.ts.map

package/dist/types/observability-providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observability-providers.d.ts","sourceRoot":"","sources":["../../src/observability-providers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,EACL,sBAAsB,EACtB,KAAK,6BAA6B,GACnC,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EACL,uBAAuB,EACvB,KAAK,8BAA8B,GACpC,MAAM,wCAAwC,CAAC"}

package/dist/types/strategies/index.d.ts

@@ -7,14 +7,28 @@
  *   - `types.ts` — typed interfaces (Observability, Cost, LiveStatus, Lens)
  *   - `defaults/` — the 4 in-core default strategies
  *
- * Vendor strategies ship as separate subpaths:
- *   - `agentfootprint/observability-agentcore` (v2.8.1)
- *   - `agentfootprint/observability-cloudwatch` (v2.8.2)
- *   - `agentfootprint/observability-xray` (v2.8.3)
- *   - `agentfootprint/observability-otel` (v2.9.x)
- *   - `agentfootprint/observability-datadog` (v2.9.x)
- *   - `agentfootprint/cost-stripe` (v2.10.x)
- *   - `agentfootprint/lens-browser` / `lens-cli` (v2.12.x)
+ * Vendor strategies ship under three GROUPED subpaths (matching the
+ * parallel-providers pattern v2.5 established for `llm-providers` /
+ * `tool-providers` / `memory-providers`). Each subpath holds N
+ * vendor-named factories — adding a vendor never adds a new subpath:
+ *
+ *   - `agentfootprint/observability-providers`
+ *       agentcoreObservability (v2.8.1)
+ *       cloudwatchObservability (v2.8.2)
+ *       xrayObservability (v2.8.3)
+ *       otelObservability (v2.9.x)
+ *       datadogObservability (v2.9.x)
+ *
+ *   - `agentfootprint/cost-providers`
+ *       stripeCost (v2.10.x)
+ *
+ *   - `agentfootprint/lens-providers`
+ *       browserLens / cliLens (v2.12.x)
+ *
+ * Each adapter lazy-imports its vendor SDK via `lib/lazyRequire.ts`,
+ * so consumers who never call a particular factory don't have to
+ * install that SDK. Peer-deps are declared in package.json with
+ * `peerDependenciesMeta.{name}.optional = true`.
  */
 export * from './types.js';
 export * from './defaults/index.js';

package/dist/types/strategies/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/strategies/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,oBAAoB,EAAE,WAAW,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AACjG,OAAO,EACL,2BAA2B,EAC3B,kBAAkB,EAClB,wBAAwB,EACxB,KAAK,0BAA0B,EAC/B,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,GAC7B,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/strategies/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,oBAAoB,EAAE,WAAW,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AACjG,OAAO,EACL,2BAA2B,EAC3B,kBAAkB,EAClB,wBAAwB,EACxB,KAAK,0BAA0B,EAC/B,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,GAC7B,MAAM,aAAa,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentfootprint",
-  "version": "2.8.0",
+  "version": "2.8.2",
   "description": "The explainable agent framework — build AI agents you can explain, audit, and trust. Built on footprintjs.",
   "license": "MIT",
   "author": "Sanjay Krishna Anbalagan",
@@ -109,6 +109,11 @@
       "import": "./dist/esm/memory-providers.js",
       "require": "./dist/memory-providers.js"
     },
+    "./observability-providers": {
+      "types": "./dist/types/observability-providers.d.ts",
+      "import": "./dist/esm/observability-providers.js",
+      "require": "./dist/observability-providers.js"
+    },
     "./observe": {
       "types": "./dist/types/observe.d.ts",
       "import": "./dist/esm/observe.js",
@@ -165,6 +170,7 @@
     "@anthropic-ai/sdk": "*",
     "@aws-sdk/client-bedrock-agent-runtime": "*",
     "@aws-sdk/client-bedrock-runtime": "*",
+    "@aws-sdk/client-cloudwatch-logs": "*",
     "@modelcontextprotocol/sdk": "*",
     "footprintjs": ">=4.17.1",
     "ioredis": "*",
@@ -184,6 +190,9 @@
     "@aws-sdk/client-bedrock-agent-runtime": {
       "optional": true
     },
+    "@aws-sdk/client-cloudwatch-logs": {
+      "optional": true
+    },
     "@modelcontextprotocol/sdk": {
       "optional": true
     },