@odigos/aws-cdk 0.0.21 → 0.0.22

package/README.md

@@ -1,6 +1,7 @@
 # Odigos CDK constructs for AWS
 
-Instrument AWS Lambda functions and ECS Fargate services with OpenTelemetry, from your own CDK app.
+Instrument AWS Lambda functions, ECS Fargate services and Amazon Bedrock AgentCore Runtimes with
+OpenTelemetry, from your own CDK app.
 
 ```bash
 npm install @odigos/aws-cdk@0.0.19
@@ -15,16 +16,17 @@ The Python distribution is built by jsii but is not published on PyPI;
 run `npm ci`, `npm run build`, then `npm run package` from `cdk/`, and install the wheel under `dist/python/`.
 For customer installation until PyPI publishing is enabled, use the CloudFormation instructions instead.
 
-| | Lambda | ECS Fargate |
-|---|---|---|
-| Construct | `OdigosLambdaInstrumentation` | `OdigosFargateInstrumentation` |
-| Mechanism | a layer, plus an exec wrapper or loader variable | agents staged into a shared task volume by a run-to-completion container |
-| Languages | python, nodejs, java, ruby | java, python, nodejs, dotnet, php, ruby |
-| Where telemetry goes | a collector in the same Lambda sandbox, which forwards | your destination, from the application process |
-| Language detection | from the function's declared runtime | none — you state the language |
+| | Lambda | ECS Fargate | AgentCore Runtime |
+|---|---|---|---|
+| Construct | `OdigosLambdaInstrumentation` | `OdigosFargateInstrumentation` | `OdigosAgentCoreInstrumentation` |
+| Mechanism | a layer, plus an exec wrapper or loader variable | agents staged into a shared task volume by a run-to-completion container | runtime environment variables; the SDK bundle is prepared into your artifact separately |
+| Languages | python, nodejs, java, ruby | java, python, nodejs, dotnet, php, ruby | python (3.12), nodejs (22, CommonJS) |
+| Where telemetry goes | a collector in the same Lambda sandbox, which forwards | your destination, from the application process | your OTLP/HTTP destination, from the application process |
+| Language detection | from the function's declared runtime | none — you state the language | none — you state the language |
 
 Lambda writes `odigos:iac=v1` and exact SDK/collector layer ARNs as function tags. Fargate writes an
-`ODIGOS_IAC` environment marker on each application container. Neither claims connector-managed ownership.
+`ODIGOS_IAC` environment marker on each application container, and AgentCore one on each runtime. None of
+them claims connector-managed ownership.
 
 # AWS Lambda
 
@@ -458,6 +460,194 @@ automatic-mode source is owned by both: each `cdk deploy` reasserts your stack's
 reconcile reasserts the connector's, and every round trip registers a revision and rolls the service.
 Discovery-only (manual) mode is the combination that works.
 
+# Amazon Bedrock AgentCore Runtime
+
+```ts
+import {
+  OdigosAgentCoreInstrumentation,
+  OdigosAgentCoreLanguage,
+  OdigosAgentCoreDistribution,
+  OdigosAgentCoreDelivery,   // only for ADOT-only artifacts, see below
+} from '@odigos/aws-cdk';
+
+const odigos = new OdigosAgentCoreInstrumentation(this, 'Odigos', {
+  destination: {
+    httpEndpoint: 'https://otlp.example.com:4318',
+    headers: { Authorization: 'Bearer <token>' },
+  },
+});
+
+odigos.instrument({
+  runtime: agentRuntime,                                // CfnRuntime, L2 Runtime, or CfnInclude resource
+  language: OdigosAgentCoreLanguage.PYTHON,
+  distribution: OdigosAgentCoreDistribution.ADOT,       // the profile prepared into the artifact
+});
+```
+
+```python
+from odigos_aws_cdk import (
+    OdigosAgentCoreInstrumentation,
+    OdigosAgentCoreLanguage,
+    OdigosAgentCoreDistribution,
+)
+
+odigos = OdigosAgentCoreInstrumentation(self, "Odigos",
+    destination={
+        "http_endpoint": "https://otlp.example.com:4318",
+        "headers": {"Authorization": "Bearer <token>"},
+    },
+)
+odigos.instrument(
+    runtime=agent_runtime,
+    language=OdigosAgentCoreLanguage.PYTHON,
+    distribution=OdigosAgentCoreDistribution.ADOT,
+)
+```
+
+`runtime` is any `AWS::BedrockAgentCore::Runtime` resource: an L1 `CfnRuntime`, a raw `CfnResource`, a
+resource from `CfnInclude.getResource()`, or a construct whose `node.defaultChild` is one (the L2
+`Runtime` in newer `aws-cdk-lib` releases). The construct writes through property overrides on
+`EnvironmentVariables`, so it needs no particular `aws-cdk-lib` version. Anything else throws at synth.
+
+## Prepare the artifact first
+
+**This construct does not install anything.** The environment it writes switches on an Odigos SDK
+bootstrap that must already be inside the artifact the runtime deploys; without it the variables are
+inert, and Odigos reports the runtime as not conformant. Prepare the artifact in your build by adding the
+Odigos package to the application's dependencies: `pip install "odigos-agentcore[adot]"` (or
+`[openllmetry]`, matching `distribution`) or `npm install @odigos/agentcore`.
+
+- **Container artifact:** Python needs nothing further; the package loads its dormant bootstrap at interpreter
+  start. For Node.js, append `--require <abs path>/node_modules/@odigos/agentcore/register.cjs` to
+  `NODE_OPTIONS`, keeping the application's existing flags.
+- **Code (ZIP) artifact:** install the package into the directory you ZIP, and set the runtime's `EntryPoint`
+  to the wrapper followed by your original entry point: `["odigos_agentcore_start.py", "app.py"]` or
+  `["node_modules/@odigos/agentcore/odigos_agentcore_start.js", "index.js"]`. The wrapper starts the
+  bootstrap and then your application.
+
+Without registry access, copy the bundle from `registry.odigos.io/odigos-agentcore-agents:<version>` instead
+(`/var/odigos/agentcore/python/3.12` or `/var/odigos/agentcore/nodejs/22`, into the image at
+`/opt/odigos/agentcore` or into the ZIP as `odigos-agentcore/`), and load its bootstrap before application
+imports: append `/opt/odigos/agentcore/bootstrap/python` to `PYTHONPATH` or `--require
+/opt/odigos/agentcore/bootstrap/node/register.cjs` to `NODE_OPTIONS`; in a ZIP, use the wrapper inside the
+bundle, `odigos-agentcore/bootstrap/python/odigos_agentcore_start.py` or `.../node/odigos_agentcore_start.js`.
+
+The full steps are at <https://docs.odigos.io/cloud-connectors/aws/workloads/agentcore/prepare>.
+`AGENTCORE_AGENTS_IMAGE` exports the bundle image this package release pairs with.
+
+### ADOT only: `delivery: ADOPT`
+
+An artifact that carries AWS Distro for OpenTelemetry and no Odigos package can be instrumented too.
+Set `delivery: OdigosAgentCoreDelivery.ADOPT` (the default is `PACKAGE`), with the ADOT distribution:
+
+```ts
+odigos.instrument({
+  runtime: agentRuntime,
+  language: OdigosAgentCoreLanguage.PYTHON,
+  delivery: OdigosAgentCoreDelivery.ADOPT,   // the artifact carries ADOT only
+});
+```
+
+Prepare the artifact with ADOT and its own launcher:
+
+- **Python:** add `aws-opentelemetry-distro` to the dependencies and start through `opentelemetry-instrument`:
+  a ZIP's `EntryPoint` becomes `["opentelemetry-instrument", "app.py"]`, a container's `CMD` is prefixed with
+  `opentelemetry-instrument`.
+- **Node.js (CommonJS):** add `@aws/aws-distro-opentelemetry-node-autoinstrumentation` and append
+  `--require @aws/aws-distro-opentelemetry-node-autoinstrumentation/register` to `NODE_OPTIONS`, on the runtime
+  or in the image, keeping existing flags. The construct does not write `NODE_OPTIONS`.
+
+The construct then writes the connector's adopt recipe (`agentCoreAdoptEnv`): the table below without
+`ODIGOS_AGENTCORE_ENABLED` and `ODIGOS_AGENTCORE_DISTRO` (both removed), `OTEL_PROPAGATORS` set to
+`tracecontext,baggage`, and `ODIGOS_AGENTCORE_PACKAGE` declaring the mode, for example
+`{"v":1,"language":"python","distros":["python-agentcore-adot"],"mode":"adopt"}` (Node.js adds
+`"moduleFormat":"commonjs"` before `mode`). The connector reads that mode and checks the runtime against the
+adopt recipe. ADOT cannot root an invocation at the agent, so AgentCore's own service span stays missing from
+the trace; the Odigos package adds it. Any distribution other than `ADOT` with `ADOPT` throws at synth.
+
+`language` and `distribution` must describe what you prepared. They are written into
+`ODIGOS_AGENTCORE_PACKAGE` and `ODIGOS_AGENTCORE_DISTRO`, which the connector checks against the
+profile, and the bootstrap starts the profile the distro names. `distribution` defaults to `ADOT`.
+
+| | `ADOT` (default) | `OPENLLMETRY` |
+|---|---|---|
+| Distro written | `<language>-agentcore-adot` | `<language>-agentcore-openllmetry` |
+| SDK | AWS Distro for OpenTelemetry | OpenLLMetry Bedrock on the upstream SDK |
+
+Only Python 3.12 and CommonJS Node.js 22 artifacts are qualified. Native ESM Node.js needs explicit SDK
+initialization and is not covered by this recipe.
+
+## What it writes
+
+With `delivery: PACKAGE` (the default; see above for `ADOPT`). Every key is compared exactly by the connector's observer, which rebuilds the same map from the
+destination configured in Odigos:
+
+| Variable | Value |
+|---|---|
+| `ODIGOS_AGENTCORE_ENABLED` | `true` |
+| `ODIGOS_AGENTCORE_DISTRO` | `<language>-agentcore-<distribution>` |
+| `ODIGOS_AGENTCORE_PACKAGE` | `{"v":1,"language":"<language>","distros":["<distro>"]}`, plus `"moduleFormat":"commonjs"` for Node.js |
+| `ODIGOS_IAC` | `{"distro":"<distro>","recipe":"1","v":1}` |
+| `DISABLE_ADOT_OBSERVABILITY` | `true` |
+| `AGENT_OBSERVABILITY_ENABLED` | `false` |
+| `OTEL_SERVICE_NAME` | see below |
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | `httpEndpoint` with trailing `/` removed |
+| `OTEL_EXPORTER_OTLP_PROTOCOL` | `http/protobuf` |
+| `OTEL_EXPORTER_OTLP_{TRACES,METRICS,LOGS}_ENDPOINT` | `<endpoint>/v1/traces`, `/v1/metrics`, `/v1/logs` |
+| `OTEL_EXPORTER_OTLP_{TRACES,METRICS,LOGS}_PROTOCOL` | `http/protobuf` |
+| `OTEL_{TRACES,METRICS,LOGS}_EXPORTER` | `otlp` when the signal is enabled, `none` otherwise |
+| `OTEL_EXPORTER_OTLP_HEADERS` | the destination headers, URL-encoded and sorted; removed when there are none |
+| `OTEL_SDK_DISABLED` | `false` |
+| `OTEL_PROPAGATORS` | `tracecontext,baggage,xray` |
+| `OTEL_TRACES_SAMPLER` | `parentbased_always_on` |
+| `OTEL_AWS_APPLICATION_SIGNALS_ENABLED` | `false` |
+| `OTEL_AWS_DYNAMIC_INSTRUMENTATION_ENABLED` | `false` |
+| `OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT` | `false` |
+| `TRACELOOP_TRACE_CONTENT` | `false` |
+| `OTEL_PYTHON_LOGGING_AUTO_INSTRUMENTATION_ENABLED` | `true` (also on Node.js, where it is inert) |
+| `OTEL_PYTHON_DISTRO` (Python) | `aws_distro` (ADOT) or `distro` (OpenLLMetry) |
+| `OTEL_PYTHON_CONFIGURATOR` (Python) | `aws_configurator` (ADOT) or `configurator` (OpenLLMetry) |
+| `OTEL_PYTHON_DISABLED_INSTRUMENTATIONS` (Python) | `boto3` (ADOT) or `botocore,aws_langchain,aws_openai_agents,aws_llama-index,aws_crewai,aws_mcp` (OpenLLMetry) |
+
+It also **removes** `OTEL_EXPORTER_OTLP_{TRACES,METRICS,LOGS}_HEADERS`, because a signal-specific header
+overrides the shared credential, and `ODIGOS_MANAGED`, which is the connector's own ownership marker.
+Other variables the runtime sets are kept. Replacing one the runtime already sets to a different value is
+a synth warning. AgentCore allows at most 50 variables; the recipe uses 27–30 of them. Synth warns when
+the known total would exceed 50, or when its size exceeds the platform byte limit (1536 bytes for V2 code
+artifacts, 2560 for V2 containers).
+
+Prompt, response and tool content capture stays off. The Python bootstrap also strips GenAI content
+attributes that some instrumentations record regardless of that setting.
+
+## Destination
+
+AgentCore exports **directly** to a global OTLP/HTTP destination. `httpEndpoint` is required and
+`endpoint` (gRPC) is rejected. The URL must be an `http` or `https` base URL without credentials, query or
+fragment, and without a per-signal `/v1/traces`, `/v1/metrics` or `/v1/logs` path: the recipe adds those
+paths itself. `destination.headers` is written into `OTEL_EXPORTER_OTLP_HEADERS` as plain runtime
+configuration, readable by anyone with `bedrock-agentcore:GetAgentRuntime`. Pass raw header values and
+let the construct encode them.
+
+## Service names
+
+`OTEL_SERVICE_NAME` defaults to the runtime's `AgentRuntimeName` when the template gives it as a literal
+string. That is also the workload name Odigos uses, unless a service name override is configured there.
+When the name is a token, such as a `Fn::Join` with the stack name, pass `serviceName`; synth throws
+otherwise.
+
+## Signals
+
+Same defaults as Lambda and Fargate: traces on, metrics and logs opt-in. They must match the signals the
+destination has in Odigos. All three exporter selectors are written explicitly, and at least one signal
+must be enabled.
+
+## Do not also enable automatic mode for these runtimes
+
+The connector refuses to install or manage a runtime that carries `ODIGOS_IAC`, and reports it as an
+error. Leave AgentCore sources in discovery-only (manual) mode in Odigos: Odigos observes and reports, and
+your stack owns the configuration. To hand a runtime to automatic mode, remove this construct and deploy
+first.
+
 # Bill of materials and removal
 
 | Flow | Resources and configuration left by deployment |
@@ -466,6 +656,7 @@ Discovery-only (manual) mode is the combination that works.
 | Lambda `IN_ACCOUNT` | The above plus one SAR nested stack/layer per artifact family and architecture; ADOT adds the shared collector application |
 | Application Signals | The above plus a managed-policy attachment on the Lambda role; account-wide discovery is configured separately |
 | Fargate | A task-definition revision with one non-essential copier, one shared volume, mounts/dependencies, activation/export environment and per-container IaC marker; an ECS deployment when the service references that revision |
+| AgentCore Runtime | Environment variables on the runtime (export settings, profile selection, `ODIGOS_AGENTCORE_PACKAGE`, `ODIGOS_IAC`) and a new runtime version when it deploys. The prepared SDK bundle in your artifact comes from your own build, not this construct |
 
 The constructs do not create a regional Collector, network routes, telemetry destination, or customer
 credentials. Provision and remove those using their separate guides. Registry access and destination
@@ -477,7 +668,9 @@ To uninstall instrumentation while keeping the application:
    `instrument()` calls or aspect from your app. Restore any explicit loader override you no longer want.
 2. Run `cdk diff`, review removal of the instrumentation resources/settings, then run `cdk deploy`.
    For Lambda, publish the uninstrumented version and move every serving alias to it. For Fargate,
-   ensure the service references the new task revision and wait for the rollout to finish.
+   ensure the service references the new task revision and wait for the rollout to finish. For
+   AgentCore, wait for the `DEFAULT` endpoint to serve the new version, update custom endpoints, and
+   remove the SDK bundle from your artifact build if you no longer want it.
 3. Verify the application is healthy and sends no new Odigos telemetry. Old published Lambda versions
    and ECS revisions remain instrumented until retired; review all traffic and rollback references first.
 4. SAR layers use retention policies and can remain after stack removal. After no function or published
@@ -499,7 +692,12 @@ To uninstall instrumentation while keeping the application:
 | `OdigosFargateInstrumentation` | the Fargate construct; `instrument(target)`, `instrumentAll(targets)` |
 | `OdigosFargateTarget` | one container to instrument: `container`, `language`, `service` / `serviceName`, `runtimeVersion`, `existingLoaderValue` |
 | `OdigosFargateLanguage` | `JAVA` \| `PYTHON` \| `NODEJS` \| `DOTNET` \| `PHP` \| `RUBY` |
-| `OdigosDestination` | where telemetry goes; exactly one endpoint on Lambda, either or both on Fargate |
+| `OdigosAgentCoreInstrumentation` | the AgentCore construct; `instrument(target)` |
+| `OdigosAgentCoreTarget` | one runtime to instrument: `runtime`, `language`, `distribution`, `delivery`, `serviceName` |
+| `OdigosAgentCoreLanguage` | `PYTHON` \| `NODEJS` |
+| `OdigosAgentCoreDistribution` | `ADOT` \| `OPENLLMETRY` |
+| `OdigosAgentCoreDelivery` | `PACKAGE` (Odigos package or carrier bundle) \| `ADOPT` (ADOT only) |
+| `OdigosDestination` | where telemetry goes; exactly one endpoint on Lambda, either or both on Fargate, `httpEndpoint` only on AgentCore |
 | `OdigosLayerSource` | `ODIGOS_PUBLIC` \| `IN_ACCOUNT` |
 | `OdigosInstrumentationMode` | `HANDLER` \| `WEB_SERVER` |
 | `OdigosJavaHandlerDistro` | the four Java wrappers |
@@ -507,6 +705,8 @@ To uninstall instrumentation while keeping the application:
 | `sidecarCommand`, `evaluateAppendPattern` | the Fargate staging command and loader-value rendering |
 | `LAYER_ARNS`, `ODIGOS_VERSION` | the baked layer table and the release it came from |
 | `FARGATE_AGENTS_IMAGE`, `FARGATE_DISTROS_VERSION` | the agents image this build stages, and the distros release its recipes mirror |
+| `AGENTCORE_AGENTS_IMAGE`, `AGENTCORE_RECIPE_VERSION`, `AGENTCORE_DISTRIBUTIONS` | the AgentCore SDK bundle image for this release, the connector recipe version, and the profile catalog |
+| `agentCoreEnvironment`, `renderAgentCoreHeaders` | the AgentCore environment recipe and header encoding (TypeScript only) |
 
 ## License
 

package/lib/agentcore-recipes.d.ts

@@ -0,0 +1,84 @@
+import { OdigosDestination } from './types';
+/** `ODIGOS_AGENTCORE_PACKAGE` — the artifact preparation contract (`agentcore.PackageEnv`). */
+export declare const AGENTCORE_PACKAGE_ENV = "ODIGOS_AGENTCORE_PACKAGE";
+/** `ODIGOS_AGENTCORE_ENABLED` — switches the dormant bootstrap on (`agentcore.EnabledEnv`). */
+export declare const AGENTCORE_ENABLED_ENV = "ODIGOS_AGENTCORE_ENABLED";
+/** `ODIGOS_AGENTCORE_DISTRO` — which bundled profile the bootstrap starts (`agentcore.DistroEnv`). */
+export declare const AGENTCORE_DISTRO_ENV = "ODIGOS_AGENTCORE_DISTRO";
+/** The customer-owned instrumentation marker. */
+export declare const AGENTCORE_IAC_ENV = "ODIGOS_IAC";
+/** The connector's own ownership marker, which an IaC-managed runtime must never carry. */
+export declare const AGENTCORE_MANAGED_ENV = "ODIGOS_MANAGED";
+/** AgentCore's cap on environment variables per runtime. */
+export declare const AGENTCORE_MAX_ENV_VARS = 50;
+/** The environment one runtime is given: keys to set, and keys that must be absent. */
+export interface AgentCoreEnvironment {
+    readonly set: {
+        [key: string]: string;
+    };
+    readonly remove: string[];
+}
+/**
+ * The connector catalog name for a language/profile pair, e.g. `python-agentcore-adot`.
+ *
+ * @throws if the pair is not in the catalog this package was generated from.
+ */
+export declare function agentCoreDistroName(language: string, distribution: string): string;
+/**
+ * Go's `url.QueryEscape` followed by `strings.ReplaceAll(s, "+", "%20")`, byte for byte.
+ *
+ * QueryEscape leaves only `A-Z a-z 0-9 - _ . ~` alone and percent-encodes every other UTF-8 byte in upper
+ * case, spelling a space `+`; the connector then turns that `+` into `%20` (a literal `+` was already
+ * `%2B`). `encodeURIComponent` differs on `! ' ( ) *`, so it is not a substitute.
+ */
+export declare function agentCoreQueryEscape(value: string): string;
+/**
+ * `OTEL_EXPORTER_OTLP_HEADERS` as the connector renders it: each pair encoded, then the `k=v` strings
+ * sorted (by the encoded text, as Go's `sort.Strings` does) and comma-joined. Empty for no headers.
+ *
+ * A key or value that is an unresolved token is passed through unencoded — encoding the token's
+ * placeholder text would destroy it — and the caller is expected to warn.
+ */
+export declare function renderAgentCoreHeaders(headers?: {
+    [key: string]: string;
+}): string;
+/**
+ * Mirrors `agentCoreTarget`: AgentCore exports straight to a global OTLP/HTTP base URL.
+ *
+ * @throws on a gRPC endpoint, a URL with credentials, query or fragment, a per-signal `/v1/...` path, or
+ * no enabled signal.
+ */
+export declare function validateAgentCoreDestination(dest: OdigosDestination): void;
+/**
+ * The compact `ODIGOS_AGENTCORE_PACKAGE` value. Key order is `agentcore.Package`'s field order, which is
+ * what Go's `json.Marshal` of the struct emits; `moduleFormat` only for Node.js, where it is `commonjs`,
+ * and `mode` only for the adopt route (`agentCorePackageValue` / `agentCoreAdoptPackageValue`).
+ */
+export declare function agentCorePackage(language: string, distro: string, mode?: string): string;
+/**
+ * The compact `ODIGOS_IAC` value. Go marshals the connector's marker from a map, so its keys come out
+ * sorted: `distro`, `recipe`, `v`.
+ */
+export declare function agentCoreIaCMarker(distro: string): string;
+/**
+ * Mirrors `agentCoreEnv`, plus the two values the manual recipe adds: the preparation contract and the
+ * IaC marker. The connector's "" (remove) entries come back in `remove`, never as empty strings — an
+ * empty `OTEL_EXPORTER_OTLP_HEADERS` set in AWS is not the same as an absent one.
+ */
+export declare function agentCoreEnvironment(language: string, distro: string, service: string, dest: OdigosDestination): AgentCoreEnvironment;
+/**
+ * Mirrors `agentCoreAdoptEnv`, plus the adopt route's preparation contract and the IaC marker: the
+ * artifact runs ADOT only, so the bootstrap switches are removed and the X-Ray propagator is dropped
+ * (with an uninstrumented caller AgentCore sends only X-Amzn-Trace-Id, so the agent's server span becomes
+ * a root instead of a child of AgentCore's span). Only the ADOT distribution can be adopted.
+ */
+export declare function agentCoreAdoptEnvironment(language: string, service: string, dest: OdigosDestination): AgentCoreEnvironment;
+/**
+ * Mirrors `validateAgentCoreEnv` on the variables this recipe sets: at most 50, keys at most 100 bytes and
+ * values at most 5000.
+ *
+ * @throws when the recipe alone breaks a service limit.
+ */
+export declare function validateAgentCoreEnvironment(env: {
+    [key: string]: string;
+}): void;

package/lib/agentcore-recipes.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENTCORE_MAX_ENV_VARS = exports.AGENTCORE_MANAGED_ENV = exports.AGENTCORE_IAC_ENV = exports.AGENTCORE_DISTRO_ENV = exports.AGENTCORE_ENABLED_ENV = exports.AGENTCORE_PACKAGE_ENV = void 0;
+exports.agentCoreDistroName = agentCoreDistroName;
+exports.agentCoreQueryEscape = agentCoreQueryEscape;
+exports.renderAgentCoreHeaders = renderAgentCoreHeaders;
+exports.validateAgentCoreDestination = validateAgentCoreDestination;
+exports.agentCorePackage = agentCorePackage;
+exports.agentCoreIaCMarker = agentCoreIaCMarker;
+exports.agentCoreEnvironment = agentCoreEnvironment;
+exports.agentCoreAdoptEnvironment = agentCoreAdoptEnvironment;
+exports.validateAgentCoreEnvironment = validateAgentCoreEnvironment;
+/**
+ * The Amazon Bedrock AgentCore Runtime environment recipe.
+ *
+ * A line-for-line mirror of the connector's `agentCoreEnv`, `agentCoreAdoptEnv`, `agentCoreTarget` and
+ * `validateAgentCoreEnv` (connectors/providers/aws/pkg/workload/instrumentor/agentcore_recipes.go) and its
+ * `ODIGOS_IAC` / `ODIGOS_AGENTCORE_PACKAGE` encodings (plan_agentcore.go, agentcore/runtime.go). The connector's observer
+ * rebuilds this exact map and diffs it key by key against the runtime's environment, so every value here
+ * is compared byte for byte: a re-ordered header list or a JSON marker with its keys in another order is
+ * reported as a non-conformant runtime, not tolerated as an equivalent spelling.
+ *
+ * Internal: exported from the package index for TypeScript callers only, like the Fargate recipes. jsii
+ * does not carry free functions into Python.
+ */
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const collector_config_1 = require("./collector-config");
+const agentcore_1 = require("./generated/agentcore");
+/** `ODIGOS_AGENTCORE_PACKAGE` — the artifact preparation contract (`agentcore.PackageEnv`). */
+exports.AGENTCORE_PACKAGE_ENV = 'ODIGOS_AGENTCORE_PACKAGE';
+/** `ODIGOS_AGENTCORE_ENABLED` — switches the dormant bootstrap on (`agentcore.EnabledEnv`). */
+exports.AGENTCORE_ENABLED_ENV = 'ODIGOS_AGENTCORE_ENABLED';
+/** `ODIGOS_AGENTCORE_DISTRO` — which bundled profile the bootstrap starts (`agentcore.DistroEnv`). */
+exports.AGENTCORE_DISTRO_ENV = 'ODIGOS_AGENTCORE_DISTRO';
+/** The customer-owned instrumentation marker. */
+exports.AGENTCORE_IAC_ENV = 'ODIGOS_IAC';
+/** The connector's own ownership marker, which an IaC-managed runtime must never carry. */
+exports.AGENTCORE_MANAGED_ENV = 'ODIGOS_MANAGED';
+/** AgentCore's cap on environment variables per runtime. */
+exports.AGENTCORE_MAX_ENV_VARS = 50;
+const OTLP_HTTP_PROTOCOL = 'http/protobuf';
+const SIGNALS = ['TRACES', 'METRICS', 'LOGS'];
+/**
+ * The connector catalog name for a language/profile pair, e.g. `python-agentcore-adot`.
+ *
+ * @throws if the pair is not in the catalog this package was generated from.
+ */
+function agentCoreDistroName(language, distribution) {
+    const name = `${language}-agentcore-${distribution}`;
+    if (!agentcore_1.AGENTCORE_DISTRIBUTIONS.some((d) => d.name === name && d.language === language)) {
+        throw new Error(`Odigos: AgentCore distribution "${name}" is not in this package's catalog (${agentcore_1.AGENTCORE_DISTRIBUTIONS.map((d) => d.name).join(', ')}).`);
+    }
+    return name;
+}
+/**
+ * Go's `url.QueryEscape` followed by `strings.ReplaceAll(s, "+", "%20")`, byte for byte.
+ *
+ * QueryEscape leaves only `A-Z a-z 0-9 - _ . ~` alone and percent-encodes every other UTF-8 byte in upper
+ * case, spelling a space `+`; the connector then turns that `+` into `%20` (a literal `+` was already
+ * `%2B`). `encodeURIComponent` differs on `! ' ( ) *`, so it is not a substitute.
+ */
+function agentCoreQueryEscape(value) {
+    let out = '';
+    for (const byte of Buffer.from(value, 'utf8')) {
+        const c = String.fromCharCode(byte);
+        if (/[A-Za-z0-9\-_.~]/.test(c)) {
+            out += c;
+        }
+        else if (byte === 0x20) {
+            out += '%20';
+        }
+        else {
+            out += '%' + byte.toString(16).toUpperCase().padStart(2, '0');
+        }
+    }
+    return out;
+}
+/**
+ * `OTEL_EXPORTER_OTLP_HEADERS` as the connector renders it: each pair encoded, then the `k=v` strings
+ * sorted (by the encoded text, as Go's `sort.Strings` does) and comma-joined. Empty for no headers.
+ *
+ * A key or value that is an unresolved token is passed through unencoded — encoding the token's
+ * placeholder text would destroy it — and the caller is expected to warn.
+ */
+function renderAgentCoreHeaders(headers) {
+    const encode = (s) => (aws_cdk_lib_1.Token.isUnresolved(s) ? s : agentCoreQueryEscape(s));
+    return Object.entries(headers ?? {})
+        .map(([k, v]) => `${encode(k)}=${encode(v)}`)
+        .sort()
+        .join(',');
+}
+/**
+ * Mirrors `agentCoreTarget`: AgentCore exports straight to a global OTLP/HTTP base URL.
+ *
+ * @throws on a gRPC endpoint, a URL with credentials, query or fragment, a per-signal `/v1/...` path, or
+ * no enabled signal.
+ */
+function validateAgentCoreDestination(dest) {
+    if (!dest.httpEndpoint || dest.endpoint) {
+        throw new Error('Odigos: AgentCore requires a destination with `httpEndpoint` (OTLP/HTTP) only. The runtime exports ' +
+            'directly to it; a gRPC `endpoint` and managed collector routing are not supported.');
+    }
+    if (!aws_cdk_lib_1.Token.isUnresolved(dest.httpEndpoint)) {
+        let url;
+        try {
+            url = new URL(dest.httpEndpoint);
+        }
+        catch {
+            url = undefined;
+        }
+        if (!url || !url.host || !['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.search || url.hash) {
+            throw new Error('Odigos: AgentCore requires an HTTP(S) OTLP base URL without credentials, query or fragment.');
+        }
+        const path = url.pathname.replace(/\/+$/, '');
+        if (['/v1/traces', '/v1/logs', '/v1/metrics'].some((suffix) => path.endsWith(suffix))) {
+            throw new Error('Odigos: AgentCore OTLP endpoint must be a base URL, without a per-signal /v1 path. The recipe ' +
+                'appends /v1/traces, /v1/metrics and /v1/logs itself.');
+        }
+    }
+    (0, collector_config_1.validateDestination)(dest);
+    const enabled = (0, collector_config_1.resolvedSignals)(dest);
+    if (!enabled.traces && !enabled.metrics && !enabled.logs) {
+        throw new Error('Odigos: AgentCore cannot export the selected signals — the destination enables none of traces, ' +
+            'metrics or logs. Note that metrics and logs are OFF by default.');
+    }
+}
+/**
+ * The compact `ODIGOS_AGENTCORE_PACKAGE` value. Key order is `agentcore.Package`'s field order, which is
+ * what Go's `json.Marshal` of the struct emits; `moduleFormat` only for Node.js, where it is `commonjs`,
+ * and `mode` only for the adopt route (`agentCorePackageValue` / `agentCoreAdoptPackageValue`).
+ */
+function agentCorePackage(language, distro, mode) {
+    const value = { v: 1, language, distros: [distro] };
+    if (language === 'nodejs') {
+        value.moduleFormat = 'commonjs';
+    }
+    if (mode) {
+        value.mode = mode;
+    }
+    return JSON.stringify(value);
+}
+/**
+ * The compact `ODIGOS_IAC` value. Go marshals the connector's marker from a map, so its keys come out
+ * sorted: `distro`, `recipe`, `v`.
+ */
+function agentCoreIaCMarker(distro) {
+    return JSON.stringify({ distro, recipe: agentcore_1.AGENTCORE_RECIPE_VERSION, v: 1 });
+}
+/**
+ * Mirrors `agentCoreEnv`, plus the two values the manual recipe adds: the preparation contract and the
+ * IaC marker. The connector's "" (remove) entries come back in `remove`, never as empty strings — an
+ * empty `OTEL_EXPORTER_OTLP_HEADERS` set in AWS is not the same as an absent one.
+ */
+function agentCoreEnvironment(language, distro, service, dest) {
+    const ep = aws_cdk_lib_1.Token.isUnresolved(dest.httpEndpoint) ? dest.httpEndpoint : dest.httpEndpoint.replace(/\/+$/, '');
+    const enabled = (0, collector_config_1.resolvedSignals)(dest);
+    const set = {
+        [exports.AGENTCORE_ENABLED_ENV]: 'true',
+        [exports.AGENTCORE_DISTRO_ENV]: distro,
+        DISABLE_ADOT_OBSERVABILITY: 'true',
+        AGENT_OBSERVABILITY_ENABLED: 'false',
+        OTEL_SERVICE_NAME: service,
+        OTEL_EXPORTER_OTLP_ENDPOINT: ep,
+        OTEL_EXPORTER_OTLP_PROTOCOL: OTLP_HTTP_PROTOCOL,
+        OTEL_SDK_DISABLED: 'false',
+        OTEL_PROPAGATORS: 'tracecontext,baggage,xray',
+        OTEL_TRACES_SAMPLER: 'parentbased_always_on',
+        OTEL_AWS_APPLICATION_SIGNALS_ENABLED: 'false',
+        OTEL_AWS_DYNAMIC_INSTRUMENTATION_ENABLED: 'false',
+        OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT: 'false',
+        TRACELOOP_TRACE_CONTENT: 'false',
+        // Unconditional in the connector, including for Node.js, where it is inert.
+        OTEL_PYTHON_LOGGING_AUTO_INSTRUMENTATION_ENABLED: 'true',
+    };
+    const remove = [];
+    const signalEnabled = { TRACES: enabled.traces, METRICS: enabled.metrics, LOGS: enabled.logs };
+    for (const signal of SIGNALS) {
+        set[`OTEL_${signal}_EXPORTER`] = signalEnabled[signal] ? 'otlp' : 'none';
+        set[`OTEL_EXPORTER_OTLP_${signal}_ENDPOINT`] = `${ep}/v1/${signal.toLowerCase()}`;
+        set[`OTEL_EXPORTER_OTLP_${signal}_PROTOCOL`] = OTLP_HTTP_PROTOCOL;
+        // Removed, not emptied: a signal-specific header would override the shared credential.
+        remove.push(`OTEL_EXPORTER_OTLP_${signal}_HEADERS`);
+    }
+    const headers = renderAgentCoreHeaders(dest.headers);
+    if (headers) {
+        set.OTEL_EXPORTER_OTLP_HEADERS = headers;
+    }
+    else {
+        remove.push('OTEL_EXPORTER_OTLP_HEADERS');
+    }
+    if (language === 'python') {
+        if (distro.endsWith('-adot')) {
+            set.OTEL_PYTHON_DISTRO = 'aws_distro';
+            set.OTEL_PYTHON_CONFIGURATOR = 'aws_configurator';
+            set.OTEL_PYTHON_DISABLED_INSTRUMENTATIONS = 'boto3';
+        }
+        else {
+            set.OTEL_PYTHON_DISTRO = 'distro';
+            set.OTEL_PYTHON_CONFIGURATOR = 'configurator';
+            set.OTEL_PYTHON_DISABLED_INSTRUMENTATIONS = 'botocore,aws_langchain,aws_openai_agents,aws_llama-index,aws_crewai,aws_mcp';
+        }
+    }
+    set[exports.AGENTCORE_PACKAGE_ENV] = agentCorePackage(language, distro);
+    set[exports.AGENTCORE_IAC_ENV] = agentCoreIaCMarker(distro);
+    remove.push(exports.AGENTCORE_MANAGED_ENV);
+    return { set, remove };
+}
+/**
+ * Mirrors `agentCoreAdoptEnv`, plus the adopt route's preparation contract and the IaC marker: the
+ * artifact runs ADOT only, so the bootstrap switches are removed and the X-Ray propagator is dropped
+ * (with an uninstrumented caller AgentCore sends only X-Amzn-Trace-Id, so the agent's server span becomes
+ * a root instead of a child of AgentCore's span). Only the ADOT distribution can be adopted.
+ */
+function agentCoreAdoptEnvironment(language, service, dest) {
+    const distro = agentCoreDistroName(language, 'adot');
+    const env = agentCoreEnvironment(language, distro, service, dest);
+    const set = { ...env.set };
+    delete set[exports.AGENTCORE_ENABLED_ENV];
+    delete set[exports.AGENTCORE_DISTRO_ENV];
+    set.OTEL_PROPAGATORS = 'tracecontext,baggage';
+    set[exports.AGENTCORE_PACKAGE_ENV] = agentCorePackage(language, distro, 'adopt');
+    return { set, remove: [exports.AGENTCORE_ENABLED_ENV, exports.AGENTCORE_DISTRO_ENV, ...env.remove] };
+}
+/**
+ * Mirrors `validateAgentCoreEnv` on the variables this recipe sets: at most 50, keys at most 100 bytes and
+ * values at most 5000.
+ *
+ * @throws when the recipe alone breaks a service limit.
+ */
+function validateAgentCoreEnvironment(env) {
+    if (Object.keys(env).length > exports.AGENTCORE_MAX_ENV_VARS) {
+        throw new Error(`Odigos: AgentCore environment would exceed the ${exports.AGENTCORE_MAX_ENV_VARS}-variable limit.`);
+    }
+    for (const [k, v] of Object.entries(env)) {
+        if (aws_cdk_lib_1.Token.isUnresolved(v)) {
+            continue;
+        }
+        if (Buffer.byteLength(k) > 100 || Buffer.byteLength(v) > 5000) {
+            throw new Error(`Odigos: AgentCore environment variable ${k} exceeds the service size limit (100-byte name, 5000-byte value).`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"agentcore-recipes.js","sourceRoot":"","sources":["../src/agentcore-recipes.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The Amazon Bedrock AgentCore Runtime environment recipe.\n *\n * A line-for-line mirror of the connector's `agentCoreEnv`, `agentCoreAdoptEnv`, `agentCoreTarget` and\n * `validateAgentCoreEnv` (connectors/providers/aws/pkg/workload/instrumentor/agentcore_recipes.go) and its\n * `ODIGOS_IAC` / `ODIGOS_AGENTCORE_PACKAGE` encodings (plan_agentcore.go, agentcore/runtime.go). The connector's observer\n * rebuilds this exact map and diffs it key by key against the runtime's environment, so every value here\n * is compared byte for byte: a re-ordered header list or a JSON marker with its keys in another order is\n * reported as a non-conformant runtime, not tolerated as an equivalent spelling.\n *\n * Internal: exported from the package index for TypeScript callers only, like the Fargate recipes. jsii\n * does not carry free functions into Python.\n */\nimport { Token } from 'aws-cdk-lib';\nimport { resolvedSignals, validateDestination } from './collector-config';\nimport { AGENTCORE_DISTRIBUTIONS, AGENTCORE_RECIPE_VERSION } from './generated/agentcore';\nimport { OdigosDestination } from './types';\n\n/** `ODIGOS_AGENTCORE_PACKAGE` — the artifact preparation contract (`agentcore.PackageEnv`). */\nexport const AGENTCORE_PACKAGE_ENV = 'ODIGOS_AGENTCORE_PACKAGE';\n/** `ODIGOS_AGENTCORE_ENABLED` — switches the dormant bootstrap on (`agentcore.EnabledEnv`). */\nexport const AGENTCORE_ENABLED_ENV = 'ODIGOS_AGENTCORE_ENABLED';\n/** `ODIGOS_AGENTCORE_DISTRO` — which bundled profile the bootstrap starts (`agentcore.DistroEnv`). */\nexport const AGENTCORE_DISTRO_ENV = 'ODIGOS_AGENTCORE_DISTRO';\n/** The customer-owned instrumentation marker. */\nexport const AGENTCORE_IAC_ENV = 'ODIGOS_IAC';\n/** The connector's own ownership marker, which an IaC-managed runtime must never carry. */\nexport const AGENTCORE_MANAGED_ENV = 'ODIGOS_MANAGED';\n/** AgentCore's cap on environment variables per runtime. */\nexport const AGENTCORE_MAX_ENV_VARS = 50;\n\nconst OTLP_HTTP_PROTOCOL = 'http/protobuf';\nconst SIGNALS: Array<'TRACES' | 'METRICS' | 'LOGS'> = ['TRACES', 'METRICS', 'LOGS'];\n\n/** The environment one runtime is given: keys to set, and keys that must be absent. */\nexport interface AgentCoreEnvironment {\n  readonly set: { [key: string]: string };\n  readonly remove: string[];\n}\n\n/**\n * The connector catalog name for a language/profile pair, e.g. `python-agentcore-adot`.\n *\n * @throws if the pair is not in the catalog this package was generated from.\n */\nexport function agentCoreDistroName(language: string, distribution: string): string {\n  const name = `${language}-agentcore-${distribution}`;\n  if (!AGENTCORE_DISTRIBUTIONS.some((d) => d.name === name && d.language === language)) {\n    throw new Error(`Odigos: AgentCore distribution \"${name}\" is not in this package's catalog (${AGENTCORE_DISTRIBUTIONS.map((d) => d.name).join(', ')}).`);\n  }\n  return name;\n}\n\n/**\n * Go's `url.QueryEscape` followed by `strings.ReplaceAll(s, \"+\", \"%20\")`, byte for byte.\n *\n * QueryEscape leaves only `A-Z a-z 0-9 - _ . ~` alone and percent-encodes every other UTF-8 byte in upper\n * case, spelling a space `+`; the connector then turns that `+` into `%20` (a literal `+` was already\n * `%2B`). `encodeURIComponent` differs on `! ' ( ) *`, so it is not a substitute.\n */\nexport function agentCoreQueryEscape(value: string): string {\n  let out = '';\n  for (const byte of Buffer.from(value, 'utf8')) {\n    const c = String.fromCharCode(byte);\n    if (/[A-Za-z0-9\\-_.~]/.test(c)) {\n      out += c;\n    } else if (byte === 0x20) {\n      out += '%20';\n    } else {\n      out += '%' + byte.toString(16).toUpperCase().padStart(2, '0');\n    }\n  }\n  return out;\n}\n\n/**\n * `OTEL_EXPORTER_OTLP_HEADERS` as the connector renders it: each pair encoded, then the `k=v` strings\n * sorted (by the encoded text, as Go's `sort.Strings` does) and comma-joined. Empty for no headers.\n *\n * A key or value that is an unresolved token is passed through unencoded — encoding the token's\n * placeholder text would destroy it — and the caller is expected to warn.\n */\nexport function renderAgentCoreHeaders(headers?: { [key: string]: string }): string {\n  const encode = (s: string): string => (Token.isUnresolved(s) ? s : agentCoreQueryEscape(s));\n  return Object.entries(headers ?? {})\n    .map(([k, v]) => `${encode(k)}=${encode(v)}`)\n    .sort()\n    .join(',');\n}\n\n/**\n * Mirrors `agentCoreTarget`: AgentCore exports straight to a global OTLP/HTTP base URL.\n *\n * @throws on a gRPC endpoint, a URL with credentials, query or fragment, a per-signal `/v1/...` path, or\n * no enabled signal.\n */\nexport function validateAgentCoreDestination(dest: OdigosDestination): void {\n  if (!dest.httpEndpoint || dest.endpoint) {\n    throw new Error(\n      'Odigos: AgentCore requires a destination with `httpEndpoint` (OTLP/HTTP) only. The runtime exports ' +\n        'directly to it; a gRPC `endpoint` and managed collector routing are not supported.',\n    );\n  }\n  if (!Token.isUnresolved(dest.httpEndpoint)) {\n    let url: URL;\n    try {\n      url = new URL(dest.httpEndpoint);\n    } catch {\n      url = undefined as unknown as URL;\n    }\n    if (!url || !url.host || !['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.search || url.hash) {\n      throw new Error('Odigos: AgentCore requires an HTTP(S) OTLP base URL without credentials, query or fragment.');\n    }\n    const path = url.pathname.replace(/\\/+$/, '');\n    if (['/v1/traces', '/v1/logs', '/v1/metrics'].some((suffix) => path.endsWith(suffix))) {\n      throw new Error(\n        'Odigos: AgentCore OTLP endpoint must be a base URL, without a per-signal /v1 path. The recipe ' +\n          'appends /v1/traces, /v1/metrics and /v1/logs itself.',\n      );\n    }\n  }\n  validateDestination(dest);\n  const enabled = resolvedSignals(dest);\n  if (!enabled.traces && !enabled.metrics && !enabled.logs) {\n    throw new Error(\n      'Odigos: AgentCore cannot export the selected signals — the destination enables none of traces, ' +\n        'metrics or logs. Note that metrics and logs are OFF by default.',\n    );\n  }\n}\n\n/**\n * The compact `ODIGOS_AGENTCORE_PACKAGE` value. Key order is `agentcore.Package`'s field order, which is\n * what Go's `json.Marshal` of the struct emits; `moduleFormat` only for Node.js, where it is `commonjs`,\n * and `mode` only for the adopt route (`agentCorePackageValue` / `agentCoreAdoptPackageValue`).\n */\nexport function agentCorePackage(language: string, distro: string, mode?: string): string {\n  const value: { [key: string]: unknown } = { v: 1, language, distros: [distro] };\n  if (language === 'nodejs') {\n    value.moduleFormat = 'commonjs';\n  }\n  if (mode) {\n    value.mode = mode;\n  }\n  return JSON.stringify(value);\n}\n\n/**\n * The compact `ODIGOS_IAC` value. Go marshals the connector's marker from a map, so its keys come out\n * sorted: `distro`, `recipe`, `v`.\n */\nexport function agentCoreIaCMarker(distro: string): string {\n  return JSON.stringify({ distro, recipe: AGENTCORE_RECIPE_VERSION, v: 1 });\n}\n\n/**\n * Mirrors `agentCoreEnv`, plus the two values the manual recipe adds: the preparation contract and the\n * IaC marker. The connector's \"\" (remove) entries come back in `remove`, never as empty strings — an\n * empty `OTEL_EXPORTER_OTLP_HEADERS` set in AWS is not the same as an absent one.\n */\nexport function agentCoreEnvironment(\n  language: string,\n  distro: string,\n  service: string,\n  dest: OdigosDestination,\n): AgentCoreEnvironment {\n  const ep = Token.isUnresolved(dest.httpEndpoint) ? dest.httpEndpoint! : dest.httpEndpoint!.replace(/\\/+$/, '');\n  const enabled = resolvedSignals(dest);\n  const set: { [key: string]: string } = {\n    [AGENTCORE_ENABLED_ENV]: 'true',\n    [AGENTCORE_DISTRO_ENV]: distro,\n    DISABLE_ADOT_OBSERVABILITY: 'true',\n    AGENT_OBSERVABILITY_ENABLED: 'false',\n    OTEL_SERVICE_NAME: service,\n    OTEL_EXPORTER_OTLP_ENDPOINT: ep,\n    OTEL_EXPORTER_OTLP_PROTOCOL: OTLP_HTTP_PROTOCOL,\n    OTEL_SDK_DISABLED: 'false',\n    OTEL_PROPAGATORS: 'tracecontext,baggage,xray',\n    OTEL_TRACES_SAMPLER: 'parentbased_always_on',\n    OTEL_AWS_APPLICATION_SIGNALS_ENABLED: 'false',\n    OTEL_AWS_DYNAMIC_INSTRUMENTATION_ENABLED: 'false',\n    OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT: 'false',\n    TRACELOOP_TRACE_CONTENT: 'false',\n    // Unconditional in the connector, including for Node.js, where it is inert.\n    OTEL_PYTHON_LOGGING_AUTO_INSTRUMENTATION_ENABLED: 'true',\n  };\n  const remove: string[] = [];\n  const signalEnabled = { TRACES: enabled.traces, METRICS: enabled.metrics, LOGS: enabled.logs };\n  for (const signal of SIGNALS) {\n    set[`OTEL_${signal}_EXPORTER`] = signalEnabled[signal] ? 'otlp' : 'none';\n    set[`OTEL_EXPORTER_OTLP_${signal}_ENDPOINT`] = `${ep}/v1/${signal.toLowerCase()}`;\n    set[`OTEL_EXPORTER_OTLP_${signal}_PROTOCOL`] = OTLP_HTTP_PROTOCOL;\n    // Removed, not emptied: a signal-specific header would override the shared credential.\n    remove.push(`OTEL_EXPORTER_OTLP_${signal}_HEADERS`);\n  }\n  const headers = renderAgentCoreHeaders(dest.headers);\n  if (headers) {\n    set.OTEL_EXPORTER_OTLP_HEADERS = headers;\n  } else {\n    remove.push('OTEL_EXPORTER_OTLP_HEADERS');\n  }\n  if (language === 'python') {\n    if (distro.endsWith('-adot')) {\n      set.OTEL_PYTHON_DISTRO = 'aws_distro';\n      set.OTEL_PYTHON_CONFIGURATOR = 'aws_configurator';\n      set.OTEL_PYTHON_DISABLED_INSTRUMENTATIONS = 'boto3';\n    } else {\n      set.OTEL_PYTHON_DISTRO = 'distro';\n      set.OTEL_PYTHON_CONFIGURATOR = 'configurator';\n      set.OTEL_PYTHON_DISABLED_INSTRUMENTATIONS = 'botocore,aws_langchain,aws_openai_agents,aws_llama-index,aws_crewai,aws_mcp';\n    }\n  }\n  set[AGENTCORE_PACKAGE_ENV] = agentCorePackage(language, distro);\n  set[AGENTCORE_IAC_ENV] = agentCoreIaCMarker(distro);\n  remove.push(AGENTCORE_MANAGED_ENV);\n  return { set, remove };\n}\n\n/**\n * Mirrors `agentCoreAdoptEnv`, plus the adopt route's preparation contract and the IaC marker: the\n * artifact runs ADOT only, so the bootstrap switches are removed and the X-Ray propagator is dropped\n * (with an uninstrumented caller AgentCore sends only X-Amzn-Trace-Id, so the agent's server span becomes\n * a root instead of a child of AgentCore's span). Only the ADOT distribution can be adopted.\n */\nexport function agentCoreAdoptEnvironment(\n  language: string,\n  service: string,\n  dest: OdigosDestination,\n): AgentCoreEnvironment {\n  const distro = agentCoreDistroName(language, 'adot');\n  const env = agentCoreEnvironment(language, distro, service, dest);\n  const set = { ...env.set };\n  delete set[AGENTCORE_ENABLED_ENV];\n  delete set[AGENTCORE_DISTRO_ENV];\n  set.OTEL_PROPAGATORS = 'tracecontext,baggage';\n  set[AGENTCORE_PACKAGE_ENV] = agentCorePackage(language, distro, 'adopt');\n  return { set, remove: [AGENTCORE_ENABLED_ENV, AGENTCORE_DISTRO_ENV, ...env.remove] };\n}\n\n/**\n * Mirrors `validateAgentCoreEnv` on the variables this recipe sets: at most 50, keys at most 100 bytes and\n * values at most 5000.\n *\n * @throws when the recipe alone breaks a service limit.\n */\nexport function validateAgentCoreEnvironment(env: { [key: string]: string }): void {\n  if (Object.keys(env).length > AGENTCORE_MAX_ENV_VARS) {\n    throw new Error(`Odigos: AgentCore environment would exceed the ${AGENTCORE_MAX_ENV_VARS}-variable limit.`);\n  }\n  for (const [k, v] of Object.entries(env)) {\n    if (Token.isUnresolved(v)) {\n      continue;\n    }\n    if (Buffer.byteLength(k) > 100 || Buffer.byteLength(v) > 5000) {\n      throw new Error(`Odigos: AgentCore environment variable ${k} exceeds the service size limit (100-byte name, 5000-byte value).`);\n    }\n  }\n}\n"]}