@odigos/aws-cdk 0.0.20 → 0.0.22

package/lib/agentcore.d.ts

@@ -0,0 +1,107 @@
+import { Construct, IConstruct } from 'constructs';
+import { OdigosAgentCoreDelivery, OdigosAgentCoreDistribution, OdigosAgentCoreLanguage, OdigosDestination } from './types';
+/**
+ * One AgentCore Runtime to instrument.
+ */
+export interface OdigosAgentCoreTarget {
+    /**
+     * The runtime: an `AWS::BedrockAgentCore::Runtime` `CfnResource` (an L1 `CfnRuntime`, a raw
+     * `CfnResource`, or a resource from `CfnInclude.getResource()`), or any construct whose
+     * `node.defaultChild` is one — such as the L2 `Runtime` in newer `aws-cdk-lib` releases.
+     */
+    readonly runtime: IConstruct;
+    /**
+     * The language of the application, and of the Odigos SDK profile prepared into its artifact.
+     *
+     * Stated rather than detected: what matters is how the artifact was prepared, which the template does
+     * not say.
+     */
+    readonly language: OdigosAgentCoreLanguage;
+    /**
+     * The SDK profile prepared into the artifact. Must be the one actually bundled.
+     *
+     * @default OdigosAgentCoreDistribution.ADOT
+     */
+    readonly distribution?: OdigosAgentCoreDistribution;
+    /**
+     * How the artifact carries the SDK: the Odigos package or carrier bundle (`PACKAGE`), or AWS Distro for
+     * OpenTelemetry only (`ADOPT`). Must match how the artifact was prepared; `ADOPT` requires the ADOT
+     * distribution and leaves AgentCore's own service span missing from the trace.
+     *
+     * @default OdigosAgentCoreDelivery.PACKAGE
+     */
+    readonly delivery?: OdigosAgentCoreDelivery;
+    /**
+     * `OTEL_SERVICE_NAME` for this runtime.
+     *
+     * THIS MUST MATCH THE WORKLOAD'S NAME IN ODIGOS, which for an AgentCore runtime is the runtime name
+     * unless a service name override is configured in Odigos. A different value is reported as drift.
+     *
+     * @default - the runtime's `AgentRuntimeName`; required when that is not a literal string
+     */
+    readonly serviceName?: string;
+}
+/**
+ * Props for {@link OdigosAgentCoreInstrumentation}.
+ */
+export interface OdigosAgentCoreInstrumentationProps {
+    /**
+     * Where the runtimes export telemetry to.
+     *
+     * AgentCore exports straight to a global OTLP/HTTP destination: `httpEndpoint` must be set, as a base
+     * URL with no per-signal `/v1/...` path, and `endpoint` (gRPC) must not be.
+     */
+    readonly destination: OdigosDestination;
+    /**
+     * Runtimes to instrument on construction. More can be added with `instrument()`.
+     *
+     * @default - none
+     */
+    readonly targets?: OdigosAgentCoreTarget[];
+}
+/**
+ * Writes the Odigos environment recipe onto Amazon Bedrock AgentCore Runtimes.
+ *
+ * ```ts
+ * new OdigosAgentCoreInstrumentation(this, 'Odigos', {
+ *   destination: { httpEndpoint: 'https://otlp.example.com:4318' },
+ *   targets: [{ runtime, language: OdigosAgentCoreLanguage.PYTHON }],
+ * });
+ * ```
+ *
+ * ## What it does
+ *
+ * Sets, through property overrides on the runtime's `EnvironmentVariables`, the exact environment the
+ * Odigos AWS connector expects for a manually instrumented runtime — the export settings, the SDK
+ * profile selection, the `ODIGOS_AGENTCORE_PACKAGE` preparation contract and the `ODIGOS_IAC` marker —
+ * and removes the per-signal header variables, `ODIGOS_MANAGED`, and (when the destination has no
+ * headers) `OTEL_EXPORTER_OTLP_HEADERS`. Variables the runtime already sets are kept.
+ *
+ * ## What it does NOT do
+ *
+ * It does not prepare the artifact. The Odigos SDK bundle and its bootstrap (`delivery: PACKAGE`), or ADOT
+ * and its launcher (`delivery: ADOPT`), must already be in the image or ZIP the runtime deploys; the
+ * environment alone installs nothing, and the construct does not write `NODE_OPTIONS`. See
+ * https://docs.odigos.io/cloud-connectors/aws/workloads/agentcore/prepare.
+ *
+ * ## Do not also enable connector automatic mode for these runtimes
+ *
+ * The connector refuses to manage a runtime carrying `ODIGOS_IAC`, and an IaC-owned runtime that the
+ * connector also tries to own is reported as an error instead of being instrumented twice.
+ */
+export declare class OdigosAgentCoreInstrumentation extends Construct {
+    private static readonly owners;
+    private readonly destination;
+    private readonly instrumented;
+    constructor(scope: Construct, id: string, props: OdigosAgentCoreInstrumentationProps);
+    /**
+     * Instruments one runtime. Idempotent — instrumenting the same runtime again is a no-op.
+     */
+    instrument(target: OdigosAgentCoreTarget): void;
+    /**
+     * Warns about what synth can see of the runtime's own environment: variables the recipe replaces, a
+     * total over AgentCore's 50-variable cap, and a size over the platform's byte budget. Existing variables
+     * are only counted when the environment is a literal object.
+     */
+    private checkExisting;
+}

package/lib/agentcore.js

@@ -0,0 +1,174 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OdigosAgentCoreInstrumentation = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const constructs_1 = require("constructs");
+const agentcore_recipes_1 = require("./agentcore-recipes");
+const types_1 = require("./types");
+/** CloudFormation type of an AgentCore Runtime. */
+const RUNTIME_TYPE = 'AWS::BedrockAgentCore::Runtime';
+/** Property path prefix the environment overrides are written under. */
+const ENV_PROPERTY = 'EnvironmentVariables';
+/**
+ * Writes the Odigos environment recipe onto Amazon Bedrock AgentCore Runtimes.
+ *
+ * ```ts
+ * new OdigosAgentCoreInstrumentation(this, 'Odigos', {
+ *   destination: { httpEndpoint: 'https://otlp.example.com:4318' },
+ *   targets: [{ runtime, language: OdigosAgentCoreLanguage.PYTHON }],
+ * });
+ * ```
+ *
+ * ## What it does
+ *
+ * Sets, through property overrides on the runtime's `EnvironmentVariables`, the exact environment the
+ * Odigos AWS connector expects for a manually instrumented runtime — the export settings, the SDK
+ * profile selection, the `ODIGOS_AGENTCORE_PACKAGE` preparation contract and the `ODIGOS_IAC` marker —
+ * and removes the per-signal header variables, `ODIGOS_MANAGED`, and (when the destination has no
+ * headers) `OTEL_EXPORTER_OTLP_HEADERS`. Variables the runtime already sets are kept.
+ *
+ * ## What it does NOT do
+ *
+ * It does not prepare the artifact. The Odigos SDK bundle and its bootstrap (`delivery: PACKAGE`), or ADOT
+ * and its launcher (`delivery: ADOPT`), must already be in the image or ZIP the runtime deploys; the
+ * environment alone installs nothing, and the construct does not write `NODE_OPTIONS`. See
+ * https://docs.odigos.io/cloud-connectors/aws/workloads/agentcore/prepare.
+ *
+ * ## Do not also enable connector automatic mode for these runtimes
+ *
+ * The connector refuses to manage a runtime carrying `ODIGOS_IAC`, and an IaC-owned runtime that the
+ * connector also tries to own is reported as an error instead of being instrumented twice.
+ */
+class OdigosAgentCoreInstrumentation extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.instrumented = new Set();
+        (0, agentcore_recipes_1.validateAgentCoreDestination)(props.destination);
+        this.destination = props.destination;
+        if (props.destination.profiles) {
+            aws_cdk_lib_1.Annotations.of(this).addWarningV2('@odigos/aws-cdk:profilesUnsupported', 'The AgentCore SDK profiles do not generate OTLP profiles. Other selected signals remain enabled.');
+        }
+        const headers = props.destination.headers ?? {};
+        if (Object.entries(headers).some(([k, v]) => aws_cdk_lib_1.Token.isUnresolved(k) || aws_cdk_lib_1.Token.isUnresolved(v))) {
+            aws_cdk_lib_1.Annotations.of(this).addWarningV2('@odigos/aws-cdk:agentCoreHeaderToken', 'Odigos: a destination header key or value is an unresolved token, so it is written unencoded into ' +
+                'OTEL_EXPORTER_OTLP_HEADERS. Make sure it resolves to an already percent-encoded value.');
+        }
+        for (const target of props.targets ?? []) {
+            this.instrument(target);
+        }
+    }
+    /**
+     * Instruments one runtime. Idempotent — instrumenting the same runtime again is a no-op.
+     */
+    instrument(target) {
+        const resource = runtimeResource(target.runtime);
+        const key = resource.node.path;
+        if (this.instrumented.has(key)) {
+            return;
+        }
+        const owner = OdigosAgentCoreInstrumentation.owners.get(resource);
+        if (owner && owner !== this) {
+            throw new Error(`Odigos: AgentCore runtime ${key} is already instrumented. Reuse its original instrumentation construct.`);
+        }
+        const language = target.language;
+        const delivery = target.delivery ?? types_1.OdigosAgentCoreDelivery.PACKAGE;
+        const distribution = target.distribution ?? types_1.OdigosAgentCoreDistribution.ADOT;
+        if (delivery === types_1.OdigosAgentCoreDelivery.ADOPT && distribution !== types_1.OdigosAgentCoreDistribution.ADOT) {
+            throw new Error(`Odigos: AgentCore runtime ${key} uses delivery ADOPT, which configures the ADOT the artifact already ` +
+                `runs; distribution ${distribution} needs the Odigos package (delivery PACKAGE).`);
+        }
+        const distro = (0, agentcore_recipes_1.agentCoreDistroName)(language, distribution);
+        const service = target.serviceName ?? literalRuntimeName(resource);
+        if (service === undefined || service === '') {
+            throw new Error(`Odigos: AgentCore runtime ${key} has no literal AgentRuntimeName, so OTEL_SERVICE_NAME cannot be ` +
+                'derived. Pass `serviceName` with the name Odigos reports the runtime under.');
+        }
+        const env = delivery === types_1.OdigosAgentCoreDelivery.ADOPT
+            ? (0, agentcore_recipes_1.agentCoreAdoptEnvironment)(language, service, this.destination)
+            : (0, agentcore_recipes_1.agentCoreEnvironment)(language, distro, service, this.destination);
+        (0, agentcore_recipes_1.validateAgentCoreEnvironment)(env.set);
+        this.checkExisting(resource, env.set, env.remove);
+        for (const [name, value] of Object.entries(env.set)) {
+            resource.addPropertyOverride(`${ENV_PROPERTY}.${name}`, value);
+        }
+        for (const name of env.remove) {
+            resource.addPropertyDeletionOverride(`${ENV_PROPERTY}.${name}`);
+        }
+        this.instrumented.add(key);
+        OdigosAgentCoreInstrumentation.owners.set(resource, this);
+    }
+    /**
+     * Warns about what synth can see of the runtime's own environment: variables the recipe replaces, a
+     * total over AgentCore's 50-variable cap, and a size over the platform's byte budget. Existing variables
+     * are only counted when the environment is a literal object.
+     */
+    checkExisting(resource, set, remove) {
+        const existing = literalProperty(resource, 'EnvironmentVariables');
+        const current = existing && typeof existing === 'object' && !Array.isArray(existing) && !aws_cdk_lib_1.Token.isUnresolved(existing)
+            ? existing
+            : {};
+        const replaced = Object.keys(set)
+            .filter((k) => !k.startsWith('ODIGOS_') && typeof current[k] === 'string' && current[k] !== set[k])
+            .sort();
+        if (replaced.length) {
+            aws_cdk_lib_1.Annotations.of(resource).addWarningV2('@odigos/aws-cdk:agentCoreEnvOverwritten', `Odigos: AgentCore runtime ${resource.node.path} already sets ${replaced.join(', ')}, which the ` +
+                'Odigos recipe replaces. The connector compares these exactly, so they cannot be kept.');
+        }
+        const merged = { ...current, ...set };
+        for (const name of remove) {
+            delete merged[name];
+        }
+        const count = Object.keys(merged).length;
+        if (count > agentcore_recipes_1.AGENTCORE_MAX_ENV_VARS) {
+            aws_cdk_lib_1.Annotations.of(resource).addWarningV2('@odigos/aws-cdk:agentCoreEnvLimit', `Odigos: AgentCore runtime ${resource.node.path} would have ${count} environment variables, over ` +
+                `AgentCore's limit of ${agentcore_recipes_1.AGENTCORE_MAX_ENV_VARS}. The deployment will be rejected.`);
+        }
+        // The connector's validateAgentCoreRuntimeEnv: 4096 bytes, but 2560 on platform V2 and 1536 for a V2
+        // code (ZIP) artifact. The platform version is not a template property, so warn at the tighter limit.
+        const bytes = Object.entries(merged).reduce((n, [k, v]) => n + k.length + (typeof v === 'string' && !aws_cdk_lib_1.Token.isUnresolved(v) ? v.length : 0), 0);
+        const artifact = literalProperty(resource, 'AgentRuntimeArtifact');
+        const isCode = !!artifact && typeof artifact === 'object' && ('CodeConfiguration' in artifact || 'codeConfiguration' in artifact);
+        const limit = isCode ? 1536 : 2560;
+        if (bytes > limit) {
+            aws_cdk_lib_1.Annotations.of(resource).addWarningV2('@odigos/aws-cdk:agentCoreEnvSize', `Odigos: AgentCore runtime ${resource.node.path} environment is about ${bytes} bytes, over the ` +
+                `${limit}-byte limit AgentCore applies to ${isCode ? 'code' : 'container'} artifacts on platform V2 ` +
+                '(4096 otherwise). Reduce application variables or header size if the deployment is rejected.');
+        }
+    }
+}
+exports.OdigosAgentCoreInstrumentation = OdigosAgentCoreInstrumentation;
+_a = JSII_RTTI_SYMBOL_1;
+OdigosAgentCoreInstrumentation[_a] = { fqn: "@odigos/aws-cdk.OdigosAgentCoreInstrumentation", version: "0.0.22" };
+// A runtime has one environment; two constructs writing it would silently overwrite each other.
+OdigosAgentCoreInstrumentation.owners = new WeakMap();
+/** The `AWS::BedrockAgentCore::Runtime` resource behind a target. */
+function runtimeResource(runtime) {
+    const candidates = [runtime, runtime.node.defaultChild];
+    for (const c of candidates) {
+        if (c instanceof aws_cdk_lib_1.CfnResource && c.cfnResourceType === RUNTIME_TYPE) {
+            return c;
+        }
+    }
+    throw new Error(`Odigos: ${runtime.node.path} is not an ${RUNTIME_TYPE} resource, nor a construct whose defaultChild is ` +
+        'one. Pass the CfnRuntime / CfnResource (or the L2 Runtime that wraps it).');
+}
+/**
+ * A top-level property as the resource was given it, under either spelling: PascalCase for a raw
+ * `CfnResource` or a `CfnInclude` resource, camelCase for a generated L1 such as `CfnRuntime`.
+ *
+ * `cfnProperties` is protected on `CfnResource`. It is read rather than resolved through the stack,
+ * because resolving an L2's lazy environment here would cache it before later additions.
+ */
+function literalProperty(resource, pascal) {
+    const props = resource.cfnProperties ?? {};
+    const camel = pascal.charAt(0).toLowerCase() + pascal.slice(1);
+    return props[pascal] ?? props[camel];
+}
+/** The runtime's `AgentRuntimeName` when it is a literal string; undefined for a token or absence. */
+function literalRuntimeName(resource) {
+    const name = literalProperty(resource, 'AgentRuntimeName');
+    return typeof name === 'string' && !aws_cdk_lib_1.Token.isUnresolved(name) ? name : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"agentcore.js","sourceRoot":"","sources":["../src/agentcore.ts"],"names":[],"mappings":"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","sourcesContent":["import { Annotations, CfnResource, Token } from 'aws-cdk-lib';\nimport { Construct, IConstruct } from 'constructs';\nimport {\n  AGENTCORE_MAX_ENV_VARS,\n  agentCoreAdoptEnvironment,\n  agentCoreDistroName,\n  agentCoreEnvironment,\n  validateAgentCoreDestination,\n  validateAgentCoreEnvironment,\n} from './agentcore-recipes';\nimport { OdigosAgentCoreDelivery, OdigosAgentCoreDistribution, OdigosAgentCoreLanguage, OdigosDestination } from './types';\n\n/** CloudFormation type of an AgentCore Runtime. */\nconst RUNTIME_TYPE = 'AWS::BedrockAgentCore::Runtime';\n\n/** Property path prefix the environment overrides are written under. */\nconst ENV_PROPERTY = 'EnvironmentVariables';\n\n/**\n * One AgentCore Runtime to instrument.\n */\nexport interface OdigosAgentCoreTarget {\n  /**\n   * The runtime: an `AWS::BedrockAgentCore::Runtime` `CfnResource` (an L1 `CfnRuntime`, a raw\n   * `CfnResource`, or a resource from `CfnInclude.getResource()`), or any construct whose\n   * `node.defaultChild` is one — such as the L2 `Runtime` in newer `aws-cdk-lib` releases.\n   */\n  readonly runtime: IConstruct;\n\n  /**\n   * The language of the application, and of the Odigos SDK profile prepared into its artifact.\n   *\n   * Stated rather than detected: what matters is how the artifact was prepared, which the template does\n   * not say.\n   */\n  readonly language: OdigosAgentCoreLanguage;\n\n  /**\n   * The SDK profile prepared into the artifact. Must be the one actually bundled.\n   *\n   * @default OdigosAgentCoreDistribution.ADOT\n   */\n  readonly distribution?: OdigosAgentCoreDistribution;\n\n  /**\n   * How the artifact carries the SDK: the Odigos package or carrier bundle (`PACKAGE`), or AWS Distro for\n   * OpenTelemetry only (`ADOPT`). Must match how the artifact was prepared; `ADOPT` requires the ADOT\n   * distribution and leaves AgentCore's own service span missing from the trace.\n   *\n   * @default OdigosAgentCoreDelivery.PACKAGE\n   */\n  readonly delivery?: OdigosAgentCoreDelivery;\n\n  /**\n   * `OTEL_SERVICE_NAME` for this runtime.\n   *\n   * THIS MUST MATCH THE WORKLOAD'S NAME IN ODIGOS, which for an AgentCore runtime is the runtime name\n   * unless a service name override is configured in Odigos. A different value is reported as drift.\n   *\n   * @default - the runtime's `AgentRuntimeName`; required when that is not a literal string\n   */\n  readonly serviceName?: string;\n}\n\n/**\n * Props for {@link OdigosAgentCoreInstrumentation}.\n */\nexport interface OdigosAgentCoreInstrumentationProps {\n  /**\n   * Where the runtimes export telemetry to.\n   *\n   * AgentCore exports straight to a global OTLP/HTTP destination: `httpEndpoint` must be set, as a base\n   * URL with no per-signal `/v1/...` path, and `endpoint` (gRPC) must not be.\n   */\n  readonly destination: OdigosDestination;\n\n  /**\n   * Runtimes to instrument on construction. More can be added with `instrument()`.\n   *\n   * @default - none\n   */\n  readonly targets?: OdigosAgentCoreTarget[];\n}\n\n/**\n * Writes the Odigos environment recipe onto Amazon Bedrock AgentCore Runtimes.\n *\n * ```ts\n * new OdigosAgentCoreInstrumentation(this, 'Odigos', {\n *   destination: { httpEndpoint: 'https://otlp.example.com:4318' },\n *   targets: [{ runtime, language: OdigosAgentCoreLanguage.PYTHON }],\n * });\n * ```\n *\n * ## What it does\n *\n * Sets, through property overrides on the runtime's `EnvironmentVariables`, the exact environment the\n * Odigos AWS connector expects for a manually instrumented runtime — the export settings, the SDK\n * profile selection, the `ODIGOS_AGENTCORE_PACKAGE` preparation contract and the `ODIGOS_IAC` marker —\n * and removes the per-signal header variables, `ODIGOS_MANAGED`, and (when the destination has no\n * headers) `OTEL_EXPORTER_OTLP_HEADERS`. Variables the runtime already sets are kept.\n *\n * ## What it does NOT do\n *\n * It does not prepare the artifact. The Odigos SDK bundle and its bootstrap (`delivery: PACKAGE`), or ADOT\n * and its launcher (`delivery: ADOPT`), must already be in the image or ZIP the runtime deploys; the\n * environment alone installs nothing, and the construct does not write `NODE_OPTIONS`. See\n * https://docs.odigos.io/cloud-connectors/aws/workloads/agentcore/prepare.\n *\n * ## Do not also enable connector automatic mode for these runtimes\n *\n * The connector refuses to manage a runtime carrying `ODIGOS_IAC`, and an IaC-owned runtime that the\n * connector also tries to own is reported as an error instead of being instrumented twice.\n */\nexport class OdigosAgentCoreInstrumentation extends Construct {\n  // A runtime has one environment; two constructs writing it would silently overwrite each other.\n  private static readonly owners = new WeakMap<CfnResource, OdigosAgentCoreInstrumentation>();\n  private readonly destination: OdigosDestination;\n  private readonly instrumented = new Set<string>();\n\n  constructor(scope: Construct, id: string, props: OdigosAgentCoreInstrumentationProps) {\n    super(scope, id);\n    validateAgentCoreDestination(props.destination);\n    this.destination = props.destination;\n    if (props.destination.profiles) {\n      Annotations.of(this).addWarningV2('@odigos/aws-cdk:profilesUnsupported',\n        'The AgentCore SDK profiles do not generate OTLP profiles. Other selected signals remain enabled.');\n    }\n    const headers = props.destination.headers ?? {};\n    if (Object.entries(headers).some(([k, v]) => Token.isUnresolved(k) || Token.isUnresolved(v))) {\n      Annotations.of(this).addWarningV2('@odigos/aws-cdk:agentCoreHeaderToken',\n        'Odigos: a destination header key or value is an unresolved token, so it is written unencoded into ' +\n          'OTEL_EXPORTER_OTLP_HEADERS. Make sure it resolves to an already percent-encoded value.');\n    }\n    for (const target of props.targets ?? []) {\n      this.instrument(target);\n    }\n  }\n\n  /**\n   * Instruments one runtime. Idempotent — instrumenting the same runtime again is a no-op.\n   */\n  public instrument(target: OdigosAgentCoreTarget): void {\n    const resource = runtimeResource(target.runtime);\n    const key = resource.node.path;\n    if (this.instrumented.has(key)) {\n      return;\n    }\n    const owner = OdigosAgentCoreInstrumentation.owners.get(resource);\n    if (owner && owner !== this) {\n      throw new Error(`Odigos: AgentCore runtime ${key} is already instrumented. Reuse its original instrumentation construct.`);\n    }\n\n    const language = target.language;\n    const delivery = target.delivery ?? OdigosAgentCoreDelivery.PACKAGE;\n    const distribution = target.distribution ?? OdigosAgentCoreDistribution.ADOT;\n    if (delivery === OdigosAgentCoreDelivery.ADOPT && distribution !== OdigosAgentCoreDistribution.ADOT) {\n      throw new Error(\n        `Odigos: AgentCore runtime ${key} uses delivery ADOPT, which configures the ADOT the artifact already ` +\n          `runs; distribution ${distribution} needs the Odigos package (delivery PACKAGE).`,\n      );\n    }\n    const distro = agentCoreDistroName(language, distribution);\n    const service = target.serviceName ?? literalRuntimeName(resource);\n    if (service === undefined || service === '') {\n      throw new Error(\n        `Odigos: AgentCore runtime ${key} has no literal AgentRuntimeName, so OTEL_SERVICE_NAME cannot be ` +\n          'derived. Pass `serviceName` with the name Odigos reports the runtime under.',\n      );\n    }\n\n    const env = delivery === OdigosAgentCoreDelivery.ADOPT\n      ? agentCoreAdoptEnvironment(language, service, this.destination)\n      : agentCoreEnvironment(language, distro, service, this.destination);\n    validateAgentCoreEnvironment(env.set);\n    this.checkExisting(resource, env.set, env.remove);\n\n    for (const [name, value] of Object.entries(env.set)) {\n      resource.addPropertyOverride(`${ENV_PROPERTY}.${name}`, value);\n    }\n    for (const name of env.remove) {\n      resource.addPropertyDeletionOverride(`${ENV_PROPERTY}.${name}`);\n    }\n    this.instrumented.add(key);\n    OdigosAgentCoreInstrumentation.owners.set(resource, this);\n  }\n\n  /**\n   * Warns about what synth can see of the runtime's own environment: variables the recipe replaces, a\n   * total over AgentCore's 50-variable cap, and a size over the platform's byte budget. Existing variables\n   * are only counted when the environment is a literal object.\n   */\n  private checkExisting(resource: CfnResource, set: { [key: string]: string }, remove: string[]): void {\n    const existing = literalProperty(resource, 'EnvironmentVariables');\n    const current: { [key: string]: unknown } =\n      existing && typeof existing === 'object' && !Array.isArray(existing) && !Token.isUnresolved(existing)\n        ? existing as { [key: string]: unknown }\n        : {};\n    const replaced = Object.keys(set)\n      .filter((k) => !k.startsWith('ODIGOS_') && typeof current[k] === 'string' && current[k] !== set[k])\n      .sort();\n    if (replaced.length) {\n      Annotations.of(resource).addWarningV2('@odigos/aws-cdk:agentCoreEnvOverwritten',\n        `Odigos: AgentCore runtime ${resource.node.path} already sets ${replaced.join(', ')}, which the ` +\n          'Odigos recipe replaces. The connector compares these exactly, so they cannot be kept.');\n    }\n    const merged: { [key: string]: unknown } = { ...current, ...set };\n    for (const name of remove) {\n      delete merged[name];\n    }\n    const count = Object.keys(merged).length;\n    if (count > AGENTCORE_MAX_ENV_VARS) {\n      Annotations.of(resource).addWarningV2('@odigos/aws-cdk:agentCoreEnvLimit',\n        `Odigos: AgentCore runtime ${resource.node.path} would have ${count} environment variables, over ` +\n          `AgentCore's limit of ${AGENTCORE_MAX_ENV_VARS}. The deployment will be rejected.`);\n    }\n    // The connector's validateAgentCoreRuntimeEnv: 4096 bytes, but 2560 on platform V2 and 1536 for a V2\n    // code (ZIP) artifact. The platform version is not a template property, so warn at the tighter limit.\n    const bytes = Object.entries(merged).reduce((n, [k, v]) => n + k.length + (typeof v === 'string' && !Token.isUnresolved(v) ? v.length : 0), 0);\n    const artifact = literalProperty(resource, 'AgentRuntimeArtifact') as { [key: string]: unknown } | undefined;\n    const isCode = !!artifact && typeof artifact === 'object' && ('CodeConfiguration' in artifact || 'codeConfiguration' in artifact);\n    const limit = isCode ? 1536 : 2560;\n    if (bytes > limit) {\n      Annotations.of(resource).addWarningV2('@odigos/aws-cdk:agentCoreEnvSize',\n        `Odigos: AgentCore runtime ${resource.node.path} environment is about ${bytes} bytes, over the ` +\n          `${limit}-byte limit AgentCore applies to ${isCode ? 'code' : 'container'} artifacts on platform V2 ` +\n          '(4096 otherwise). Reduce application variables or header size if the deployment is rejected.');\n    }\n  }\n}\n\n/** The `AWS::BedrockAgentCore::Runtime` resource behind a target. */\nfunction runtimeResource(runtime: IConstruct): CfnResource {\n  const candidates = [runtime, runtime.node.defaultChild];\n  for (const c of candidates) {\n    if (c instanceof CfnResource && c.cfnResourceType === RUNTIME_TYPE) {\n      return c;\n    }\n  }\n  throw new Error(\n    `Odigos: ${runtime.node.path} is not an ${RUNTIME_TYPE} resource, nor a construct whose defaultChild is ` +\n      'one. Pass the CfnRuntime / CfnResource (or the L2 Runtime that wraps it).',\n  );\n}\n\n/**\n * A top-level property as the resource was given it, under either spelling: PascalCase for a raw\n * `CfnResource` or a `CfnInclude` resource, camelCase for a generated L1 such as `CfnRuntime`.\n *\n * `cfnProperties` is protected on `CfnResource`. It is read rather than resolved through the stack,\n * because resolving an L2's lazy environment here would cache it before later additions.\n */\nfunction literalProperty(resource: CfnResource, pascal: string): unknown {\n  const props = (resource as unknown as { cfnProperties?: { [key: string]: unknown } }).cfnProperties ?? {};\n  const camel = pascal.charAt(0).toLowerCase() + pascal.slice(1);\n  return props[pascal] ?? props[camel];\n}\n\n/** The runtime's `AgentRuntimeName` when it is a literal string; undefined for a token or absence. */\nfunction literalRuntimeName(resource: CfnResource): string | undefined {\n  const name = literalProperty(resource, 'AgentRuntimeName');\n  return typeof name === 'string' && !Token.isUnresolved(name) ? name : undefined;\n}\n"]}

package/lib/fargate.js

@@ -406,7 +406,7 @@ class OdigosFargateInstrumentation extends constructs_1.Construct {
 }
 exports.OdigosFargateInstrumentation = OdigosFargateInstrumentation;
 _a = JSII_RTTI_SYMBOL_1;
-OdigosFargateInstrumentation[_a] = { fqn: "@odigos/aws-cdk.OdigosFargateInstrumentation", version: "0.0.20" };
+OdigosFargateInstrumentation[_a] = { fqn: "@odigos/aws-cdk.OdigosFargateInstrumentation", version: "0.0.22" };
 // A task can contain targets configured by several instrumentation constructs.
 OdigosFargateInstrumentation.taskDefinitions = new WeakMap();
 OdigosFargateInstrumentation.owners = new WeakMap();

package/lib/generated/agentcore.d.ts

@@ -0,0 +1,26 @@
+/**
+ * GENERATED FILE — DO NOT EDIT.
+ *
+ * Produced by cdk/scripts/generate.ts from ../artifacts.json, ../versions.env and manifest/layers.json.
+ * Run `npm run generate` (or `npm run build`) to refresh it.
+ *
+ * Odigos artifact version: v0.0.22
+ */
+/**
+ * The AgentCore SDK bundle carrier (linux/arm64) for this package's release, holding the prepared profiles
+ * under /var/odigos/agentcore/<language>/<version>. Copy from it when preparing an artifact; the
+ * construct itself does not reference it. Empty before the first release.
+ */
+export declare const AGENTCORE_AGENTS_IMAGE = "registry.odigos.io/odigos-agentcore-agents:v0.0.22";
+/** The connector's AgentCore environment recipe version, recorded as `recipe` in ODIGOS_IAC. */
+export declare const AGENTCORE_RECIPE_VERSION = "1";
+/** One prepared AgentCore SDK profile, mirrored from the connector's catalog. */
+export interface AgentCoreDistribution {
+    readonly name: string;
+    readonly displayName: string;
+    readonly language: string;
+    readonly vendor: string;
+    readonly isDefault: boolean;
+    readonly version: string;
+}
+export declare const AGENTCORE_DISTRIBUTIONS: readonly AgentCoreDistribution[];

package/lib/generated/agentcore.js

@@ -0,0 +1,55 @@
+"use strict";
+/* eslint-disable */
+/**
+ * GENERATED FILE — DO NOT EDIT.
+ *
+ * Produced by cdk/scripts/generate.ts from ../artifacts.json, ../versions.env and manifest/layers.json.
+ * Run `npm run generate` (or `npm run build`) to refresh it.
+ *
+ * Odigos artifact version: v0.0.22
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENTCORE_DISTRIBUTIONS = exports.AGENTCORE_RECIPE_VERSION = exports.AGENTCORE_AGENTS_IMAGE = void 0;
+/**
+ * The AgentCore SDK bundle carrier (linux/arm64) for this package's release, holding the prepared profiles
+ * under /var/odigos/agentcore/<language>/<version>. Copy from it when preparing an artifact; the
+ * construct itself does not reference it. Empty before the first release.
+ */
+exports.AGENTCORE_AGENTS_IMAGE = "registry.odigos.io/odigos-agentcore-agents:v0.0.22";
+/** The connector's AgentCore environment recipe version, recorded as `recipe` in ODIGOS_IAC. */
+exports.AGENTCORE_RECIPE_VERSION = "1";
+exports.AGENTCORE_DISTRIBUTIONS = [
+    {
+        "name": "python-agentcore-adot",
+        "displayName": "AWS Distro for OpenTelemetry",
+        "language": "python",
+        "vendor": "adot",
+        "isDefault": true,
+        "version": "1"
+    },
+    {
+        "name": "python-agentcore-openllmetry",
+        "displayName": "OpenLLMetry Bedrock",
+        "language": "python",
+        "vendor": "openllmetry",
+        "isDefault": false,
+        "version": "1"
+    },
+    {
+        "name": "nodejs-agentcore-adot",
+        "displayName": "AWS Distro for OpenTelemetry",
+        "language": "nodejs",
+        "vendor": "adot",
+        "isDefault": true,
+        "version": "1"
+    },
+    {
+        "name": "nodejs-agentcore-openllmetry",
+        "displayName": "OpenLLMetry Bedrock",
+        "language": "nodejs",
+        "vendor": "openllmetry",
+        "isDefault": false,
+        "version": "1"
+    }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/lib/generated/distributions.d.ts

@@ -4,7 +4,7 @@
  * Produced by cdk/scripts/generate.ts from ../artifacts.json and ../versions.env.
  * Run `npm run generate` (or `npm run build`) to refresh it.
  *
- * Odigos artifact version: v0.0.20
+ * Odigos artifact version: v0.0.22
  */
 export interface LambdaDistribution {
     readonly name: string;

package/lib/generated/distributions.js

@@ -6,7 +6,7 @@
  * Produced by cdk/scripts/generate.ts from ../artifacts.json and ../versions.env.
  * Run `npm run generate` (or `npm run build`) to refresh it.
  *
- * Odigos artifact version: v0.0.20
+ * Odigos artifact version: v0.0.22
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LAMBDA_DISTRIBUTIONS = void 0;
@@ -280,4 +280,4 @@ exports.LAMBDA_DISTRIBUTIONS = [
         "version": "0.13.0"
     }
 ];
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"distributions.js","sourceRoot":"","sources":["../../src/generated/distributions.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable */\n/**\n * GENERATED FILE — DO NOT EDIT.\n *\n * Produced by cdk/scripts/generate.ts from ../artifacts.json and ../versions.env.\n * Run `npm run generate` (or `npm run build`) to refresh it.\n *\n * Odigos artifact version: v0.0.20\n */\n\nexport interface LambdaDistribution { readonly name: string; readonly displayName: string; readonly language: string; readonly version: string; readonly isDefault: boolean; readonly execWrapper: string; readonly artifact?: string; readonly applicationSignals?: boolean; readonly compatibleRuntimes?: readonly string[]; readonly environment?: { readonly [key: string]: string }; readonly bootstrapEnvironment?: { readonly [key: string]: string }; }\nexport const LAMBDA_DISTRIBUTIONS: readonly LambdaDistribution[] = [\n  {\n    \"name\": \"java-lambda-otel-agent\",\n    \"displayName\": \"Java Lambda OpenTelemetry agent\",\n    \"language\": \"java\",\n    \"isDefault\": true,\n    \"execWrapper\": \"/opt/otel-javaagent-handler\",\n    \"version\": \"2.32.0\"\n  },\n  {\n    \"name\": \"java-lambda-otel-wrapper\",\n    \"displayName\": \"Java Lambda OpenTelemetry generic handler\",\n    \"language\": \"java\",\n    \"isDefault\": false,\n    \"execWrapper\": \"/opt/otel-handler\",\n    \"version\": \"0.21.0\"\n  },\n  {\n    \"name\": \"java-lambda-otel-proxy-wrapper\",\n    \"displayName\": \"Java Lambda OpenTelemetry API Gateway proxy handler\",\n    \"language\": \"java\",\n    \"isDefault\": false,\n    \"execWrapper\": \"/opt/otel-proxy-handler\",\n    \"version\": \"0.21.0\"\n  },\n  {\n    \"name\": \"java-lambda-otel-sqs-wrapper\",\n    \"displayName\": \"Java Lambda OpenTelemetry SQS event handler\",\n    \"language\": \"java\",\n    \"isDefault\": false,\n    \"execWrapper\": \"/opt/otel-sqs-handler\",\n    \"version\": \"0.21.0\"\n  },\n  {\n    \"name\": \"java-lambda-otel-stream-wrapper\",\n    \"displayName\": \"Java Lambda OpenTelemetry stream handler\",\n    \"language\": \"java\",\n    \"isDefault\": false,\n    \"execWrapper\": \"/opt/otel-stream-handler\",\n    \"version\": \"0.21.0\"\n  },\n  {\n    \"name\": \"nodejs-lambda-otel\",\n    \"displayName\": \"Node.js Lambda OpenTelemetry\",\n    \"language\": \"nodejs\",\n    \"isDefault\": true,\n    \"execWrapper\": \"/opt/otel-handler\",\n    \"version\": \"0.23.0\"\n  },\n  {\n    \"name\": \"python-lambda-otel\",\n    \"displayName\": \"Python Lambda OpenTelemetry\",\n    \"language\": \"python\",\n    \"isDefault\": true,\n    \"execWrapper\": \"/opt/otel-instrument\",\n    \"version\": \"0.21.0\"\n  },\n  {\n    \"name\": \"ruby-lambda-otel\",\n    \"displayName\": \"Ruby Lambda OpenTelemetry\",\n    \"language\": \"ruby\",\n    \"isDefault\": true,\n    \"execWrapper\": \"/opt/otel-handler\",\n    \"version\": \"0.14.0\"\n  },\n  {\n    \"name\": \"java-lambda-adot\",\n    \"displayName\": \"Java Lambda AWS ADOT\",\n    \"language\": \"java\",\n    \"isDefault\": false,\n    \"execWrapper\": \"/opt/odigos-adot-java-handler\",\n    \"artifact\": \"adot-java\",\n    \"applicationSignals\": false,\n    \"compatibleRuntimes\": [\n      \"java11\",\n      \"java17\",\n      \"java21\"\n    ],\n    \"environment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_ENABLED\": \"false\"\n    },\n    \"bootstrapEnvironment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_RUNTIME_ENABLED\": \"false\",\n      \"OTEL_AWS_LAMBDA_FAST_START\": \"false\",\n      \"OTEL_PROPAGATORS\": \"tracecontext,baggage\",\n      \"OTEL_EXPORTER_OTLP_TRACES_ENDPOINT\": \"http://localhost:4318/v1/traces\",\n      \"OTEL_EXPORTER_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_EXPORTER_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\",\n      \"OTEL_INSTRUMENTATION_COMMON_DEFAULT_ENABLED\": \"true\",\n      \"OTEL_SDK_DISABLED\": \"false\",\n      \"OTEL_EXPORTER_OTLP_PROTOCOL\": \"http/protobuf\",\n      \"OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\"\n    },\n    \"version\": \"2.31.0\"\n  },\n  {\n    \"name\": \"java-lambda-adot-application-signals\",\n    \"displayName\": \"Java Lambda AWS ADOT + Application Signals\",\n    \"language\": \"java\",\n    \"isDefault\": false,\n    \"execWrapper\": \"/opt/odigos-adot-java-handler\",\n    \"artifact\": \"adot-java\",\n    \"applicationSignals\": true,\n    \"compatibleRuntimes\": [\n      \"java11\",\n      \"java17\",\n      \"java21\"\n    ],\n    \"environment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_ENABLED\": \"true\"\n    },\n    \"bootstrapEnvironment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_RUNTIME_ENABLED\": \"false\",\n      \"OTEL_AWS_LAMBDA_FAST_START\": \"false\",\n      \"OTEL_PROPAGATORS\": \"tracecontext,baggage\",\n      \"OTEL_EXPORTER_OTLP_TRACES_ENDPOINT\": \"http://localhost:4318/v1/traces\",\n      \"OTEL_EXPORTER_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_EXPORTER_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\",\n      \"OTEL_INSTRUMENTATION_COMMON_DEFAULT_ENABLED\": \"true\",\n      \"OTEL_SDK_DISABLED\": \"false\",\n      \"OTEL_EXPORTER_OTLP_PROTOCOL\": \"http/protobuf\",\n      \"OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\"\n    },\n    \"version\": \"2.31.0\"\n  },\n  {\n    \"name\": \"python-lambda-adot\",\n    \"displayName\": \"Python Lambda AWS ADOT\",\n    \"language\": \"python\",\n    \"isDefault\": false,\n    \"execWrapper\": \"/opt/otel-instrument\",\n    \"artifact\": \"adot-python\",\n    \"applicationSignals\": false,\n    \"compatibleRuntimes\": [\n      \"python3.10\",\n      \"python3.11\",\n      \"python3.12\",\n      \"python3.13\"\n    ],\n    \"environment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_ENABLED\": \"false\"\n    },\n    \"bootstrapEnvironment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_RUNTIME_ENABLED\": \"false\",\n      \"OTEL_AWS_LAMBDA_FAST_START\": \"false\",\n      \"OTEL_PROPAGATORS\": \"tracecontext,baggage\",\n      \"OTEL_EXPORTER_OTLP_TRACES_ENDPOINT\": \"http://localhost:4318/v1/traces\",\n      \"OTEL_EXPORTER_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_EXPORTER_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\",\n      \"OTEL_PYTHON_DISABLED_INSTRUMENTATIONS\": \"none\",\n      \"OTEL_PYTHON_DISTRO\": \"aws_distro\",\n      \"OTEL_PYTHON_CONFIGURATOR\": \"aws_configurator\",\n      \"OTEL_SDK_DISABLED\": \"false\",\n      \"OTEL_EXPORTER_OTLP_PROTOCOL\": \"http/protobuf\",\n      \"OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\",\n      \"OTEL_PYTHON_LOG_AUTO_INSTRUMENTATION\": \"true\"\n    },\n    \"version\": \"0.21.0\"\n  },\n  {\n    \"name\": \"python-lambda-adot-application-signals\",\n    \"displayName\": \"Python Lambda AWS ADOT + Application Signals\",\n    \"language\": \"python\",\n    \"isDefault\": false,\n    \"execWrapper\": \"/opt/otel-instrument\",\n    \"artifact\": \"adot-python\",\n    \"applicationSignals\": true,\n    \"compatibleRuntimes\": [\n      \"python3.10\",\n      \"python3.11\",\n      \"python3.12\",\n      \"python3.13\"\n    ],\n    \"environment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_ENABLED\": \"true\"\n    },\n    \"bootstrapEnvironment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_RUNTIME_ENABLED\": \"false\",\n      \"OTEL_AWS_LAMBDA_FAST_START\": \"false\",\n      \"OTEL_PROPAGATORS\": \"tracecontext,baggage\",\n      \"OTEL_EXPORTER_OTLP_TRACES_ENDPOINT\": \"http://localhost:4318/v1/traces\",\n      \"OTEL_EXPORTER_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_EXPORTER_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\",\n      \"OTEL_PYTHON_DISABLED_INSTRUMENTATIONS\": \"none\",\n      \"OTEL_PYTHON_DISTRO\": \"aws_distro\",\n      \"OTEL_PYTHON_CONFIGURATOR\": \"aws_configurator\",\n      \"OTEL_SDK_DISABLED\": \"false\",\n      \"OTEL_EXPORTER_OTLP_PROTOCOL\": \"http/protobuf\",\n      \"OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\",\n      \"OTEL_PYTHON_LOG_AUTO_INSTRUMENTATION\": \"true\"\n    },\n    \"version\": \"0.21.0\"\n  },\n  {\n    \"name\": \"nodejs-lambda-adot\",\n    \"displayName\": \"Nodejs Lambda AWS ADOT\",\n    \"language\": \"nodejs\",\n    \"isDefault\": false,\n    \"execWrapper\": \"/opt/otel-instrument\",\n    \"artifact\": \"adot-nodejs\",\n    \"applicationSignals\": false,\n    \"compatibleRuntimes\": [\n      \"nodejs18.x\",\n      \"nodejs20.x\",\n      \"nodejs22.x\",\n      \"nodejs24.x\"\n    ],\n    \"environment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_ENABLED\": \"false\"\n    },\n    \"bootstrapEnvironment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_RUNTIME_ENABLED\": \"false\",\n      \"OTEL_AWS_LAMBDA_FAST_START\": \"false\",\n      \"OTEL_PROPAGATORS\": \"tracecontext,baggage\",\n      \"OTEL_EXPORTER_OTLP_TRACES_ENDPOINT\": \"http://localhost:4318/v1/traces\",\n      \"OTEL_EXPORTER_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_EXPORTER_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\",\n      \"OTEL_NODE_DISABLED_INSTRUMENTATIONS\": \"none\",\n      \"OTEL_NODE_ENABLED_INSTRUMENTATIONS\": \"amqplib,aws-lambda,aws-sdk,bunyan,cassandra-driver,connect,cucumber,dataloader,dns,express,fs,generic-pool,graphql,grpc,hapi,host-metrics,http,ioredis,kafkajs,knex,koa,lru-memoizer,memcached,mongodb,mongoose,mysql2,mysql,nestjs-core,net,openai,oracledb,pg,pino,redis,restify,router,runtime-node,socket.io,tedious,undici,winston\",\n      \"OTEL_SDK_DISABLED\": \"false\",\n      \"OTEL_EXPORTER_OTLP_PROTOCOL\": \"http/protobuf\",\n      \"OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\"\n    },\n    \"version\": \"0.13.0\"\n  },\n  {\n    \"name\": \"nodejs-lambda-adot-application-signals\",\n    \"displayName\": \"Nodejs Lambda AWS ADOT + Application Signals\",\n    \"language\": \"nodejs\",\n    \"isDefault\": false,\n    \"execWrapper\": \"/opt/otel-instrument\",\n    \"artifact\": \"adot-nodejs\",\n    \"applicationSignals\": true,\n    \"compatibleRuntimes\": [\n      \"nodejs18.x\",\n      \"nodejs20.x\",\n      \"nodejs22.x\",\n      \"nodejs24.x\"\n    ],\n    \"environment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_ENABLED\": \"true\"\n    },\n    \"bootstrapEnvironment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_RUNTIME_ENABLED\": \"false\",\n      \"OTEL_AWS_LAMBDA_FAST_START\": \"false\",\n      \"OTEL_PROPAGATORS\": \"tracecontext,baggage\",\n      \"OTEL_EXPORTER_OTLP_TRACES_ENDPOINT\": \"http://localhost:4318/v1/traces\",\n      \"OTEL_EXPORTER_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_EXPORTER_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\",\n      \"OTEL_NODE_DISABLED_INSTRUMENTATIONS\": \"none\",\n      \"OTEL_NODE_ENABLED_INSTRUMENTATIONS\": \"amqplib,aws-lambda,aws-sdk,bunyan,cassandra-driver,connect,cucumber,dataloader,dns,express,fs,generic-pool,graphql,grpc,hapi,host-metrics,http,ioredis,kafkajs,knex,koa,lru-memoizer,memcached,mongodb,mongoose,mysql2,mysql,nestjs-core,net,openai,oracledb,pg,pino,redis,restify,router,runtime-node,socket.io,tedious,undici,winston\",\n      \"OTEL_SDK_DISABLED\": \"false\",\n      \"OTEL_EXPORTER_OTLP_PROTOCOL\": \"http/protobuf\",\n      \"OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\"\n    },\n    \"version\": \"0.13.0\"\n  }\n] as const;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"distributions.js","sourceRoot":"","sources":["../../src/generated/distributions.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable */\n/**\n * GENERATED FILE — DO NOT EDIT.\n *\n * Produced by cdk/scripts/generate.ts from ../artifacts.json and ../versions.env.\n * Run `npm run generate` (or `npm run build`) to refresh it.\n *\n * Odigos artifact version: v0.0.22\n */\n\nexport interface LambdaDistribution { readonly name: string; readonly displayName: string; readonly language: string; readonly version: string; readonly isDefault: boolean; readonly execWrapper: string; readonly artifact?: string; readonly applicationSignals?: boolean; readonly compatibleRuntimes?: readonly string[]; readonly environment?: { readonly [key: string]: string }; readonly bootstrapEnvironment?: { readonly [key: string]: string }; }\nexport const LAMBDA_DISTRIBUTIONS: readonly LambdaDistribution[] = [\n  {\n    \"name\": \"java-lambda-otel-agent\",\n    \"displayName\": \"Java Lambda OpenTelemetry agent\",\n    \"language\": \"java\",\n    \"isDefault\": true,\n    \"execWrapper\": \"/opt/otel-javaagent-handler\",\n    \"version\": \"2.32.0\"\n  },\n  {\n    \"name\": \"java-lambda-otel-wrapper\",\n    \"displayName\": \"Java Lambda OpenTelemetry generic handler\",\n    \"language\": \"java\",\n    \"isDefault\": false,\n    \"execWrapper\": \"/opt/otel-handler\",\n    \"version\": \"0.21.0\"\n  },\n  {\n    \"name\": \"java-lambda-otel-proxy-wrapper\",\n    \"displayName\": \"Java Lambda OpenTelemetry API Gateway proxy handler\",\n    \"language\": \"java\",\n    \"isDefault\": false,\n    \"execWrapper\": \"/opt/otel-proxy-handler\",\n    \"version\": \"0.21.0\"\n  },\n  {\n    \"name\": \"java-lambda-otel-sqs-wrapper\",\n    \"displayName\": \"Java Lambda OpenTelemetry SQS event handler\",\n    \"language\": \"java\",\n    \"isDefault\": false,\n    \"execWrapper\": \"/opt/otel-sqs-handler\",\n    \"version\": \"0.21.0\"\n  },\n  {\n    \"name\": \"java-lambda-otel-stream-wrapper\",\n    \"displayName\": \"Java Lambda OpenTelemetry stream handler\",\n    \"language\": \"java\",\n    \"isDefault\": false,\n    \"execWrapper\": \"/opt/otel-stream-handler\",\n    \"version\": \"0.21.0\"\n  },\n  {\n    \"name\": \"nodejs-lambda-otel\",\n    \"displayName\": \"Node.js Lambda OpenTelemetry\",\n    \"language\": \"nodejs\",\n    \"isDefault\": true,\n    \"execWrapper\": \"/opt/otel-handler\",\n    \"version\": \"0.23.0\"\n  },\n  {\n    \"name\": \"python-lambda-otel\",\n    \"displayName\": \"Python Lambda OpenTelemetry\",\n    \"language\": \"python\",\n    \"isDefault\": true,\n    \"execWrapper\": \"/opt/otel-instrument\",\n    \"version\": \"0.21.0\"\n  },\n  {\n    \"name\": \"ruby-lambda-otel\",\n    \"displayName\": \"Ruby Lambda OpenTelemetry\",\n    \"language\": \"ruby\",\n    \"isDefault\": true,\n    \"execWrapper\": \"/opt/otel-handler\",\n    \"version\": \"0.14.0\"\n  },\n  {\n    \"name\": \"java-lambda-adot\",\n    \"displayName\": \"Java Lambda AWS ADOT\",\n    \"language\": \"java\",\n    \"isDefault\": false,\n    \"execWrapper\": \"/opt/odigos-adot-java-handler\",\n    \"artifact\": \"adot-java\",\n    \"applicationSignals\": false,\n    \"compatibleRuntimes\": [\n      \"java11\",\n      \"java17\",\n      \"java21\"\n    ],\n    \"environment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_ENABLED\": \"false\"\n    },\n    \"bootstrapEnvironment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_RUNTIME_ENABLED\": \"false\",\n      \"OTEL_AWS_LAMBDA_FAST_START\": \"false\",\n      \"OTEL_PROPAGATORS\": \"tracecontext,baggage\",\n      \"OTEL_EXPORTER_OTLP_TRACES_ENDPOINT\": \"http://localhost:4318/v1/traces\",\n      \"OTEL_EXPORTER_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_EXPORTER_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\",\n      \"OTEL_INSTRUMENTATION_COMMON_DEFAULT_ENABLED\": \"true\",\n      \"OTEL_SDK_DISABLED\": \"false\",\n      \"OTEL_EXPORTER_OTLP_PROTOCOL\": \"http/protobuf\",\n      \"OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\"\n    },\n    \"version\": \"2.31.0\"\n  },\n  {\n    \"name\": \"java-lambda-adot-application-signals\",\n    \"displayName\": \"Java Lambda AWS ADOT + Application Signals\",\n    \"language\": \"java\",\n    \"isDefault\": false,\n    \"execWrapper\": \"/opt/odigos-adot-java-handler\",\n    \"artifact\": \"adot-java\",\n    \"applicationSignals\": true,\n    \"compatibleRuntimes\": [\n      \"java11\",\n      \"java17\",\n      \"java21\"\n    ],\n    \"environment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_ENABLED\": \"true\"\n    },\n    \"bootstrapEnvironment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_RUNTIME_ENABLED\": \"false\",\n      \"OTEL_AWS_LAMBDA_FAST_START\": \"false\",\n      \"OTEL_PROPAGATORS\": \"tracecontext,baggage\",\n      \"OTEL_EXPORTER_OTLP_TRACES_ENDPOINT\": \"http://localhost:4318/v1/traces\",\n      \"OTEL_EXPORTER_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_EXPORTER_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\",\n      \"OTEL_INSTRUMENTATION_COMMON_DEFAULT_ENABLED\": \"true\",\n      \"OTEL_SDK_DISABLED\": \"false\",\n      \"OTEL_EXPORTER_OTLP_PROTOCOL\": \"http/protobuf\",\n      \"OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\"\n    },\n    \"version\": \"2.31.0\"\n  },\n  {\n    \"name\": \"python-lambda-adot\",\n    \"displayName\": \"Python Lambda AWS ADOT\",\n    \"language\": \"python\",\n    \"isDefault\": false,\n    \"execWrapper\": \"/opt/otel-instrument\",\n    \"artifact\": \"adot-python\",\n    \"applicationSignals\": false,\n    \"compatibleRuntimes\": [\n      \"python3.10\",\n      \"python3.11\",\n      \"python3.12\",\n      \"python3.13\"\n    ],\n    \"environment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_ENABLED\": \"false\"\n    },\n    \"bootstrapEnvironment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_RUNTIME_ENABLED\": \"false\",\n      \"OTEL_AWS_LAMBDA_FAST_START\": \"false\",\n      \"OTEL_PROPAGATORS\": \"tracecontext,baggage\",\n      \"OTEL_EXPORTER_OTLP_TRACES_ENDPOINT\": \"http://localhost:4318/v1/traces\",\n      \"OTEL_EXPORTER_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_EXPORTER_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\",\n      \"OTEL_PYTHON_DISABLED_INSTRUMENTATIONS\": \"none\",\n      \"OTEL_PYTHON_DISTRO\": \"aws_distro\",\n      \"OTEL_PYTHON_CONFIGURATOR\": \"aws_configurator\",\n      \"OTEL_SDK_DISABLED\": \"false\",\n      \"OTEL_EXPORTER_OTLP_PROTOCOL\": \"http/protobuf\",\n      \"OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\",\n      \"OTEL_PYTHON_LOG_AUTO_INSTRUMENTATION\": \"true\"\n    },\n    \"version\": \"0.21.0\"\n  },\n  {\n    \"name\": \"python-lambda-adot-application-signals\",\n    \"displayName\": \"Python Lambda AWS ADOT + Application Signals\",\n    \"language\": \"python\",\n    \"isDefault\": false,\n    \"execWrapper\": \"/opt/otel-instrument\",\n    \"artifact\": \"adot-python\",\n    \"applicationSignals\": true,\n    \"compatibleRuntimes\": [\n      \"python3.10\",\n      \"python3.11\",\n      \"python3.12\",\n      \"python3.13\"\n    ],\n    \"environment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_ENABLED\": \"true\"\n    },\n    \"bootstrapEnvironment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_RUNTIME_ENABLED\": \"false\",\n      \"OTEL_AWS_LAMBDA_FAST_START\": \"false\",\n      \"OTEL_PROPAGATORS\": \"tracecontext,baggage\",\n      \"OTEL_EXPORTER_OTLP_TRACES_ENDPOINT\": \"http://localhost:4318/v1/traces\",\n      \"OTEL_EXPORTER_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_EXPORTER_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\",\n      \"OTEL_PYTHON_DISABLED_INSTRUMENTATIONS\": \"none\",\n      \"OTEL_PYTHON_DISTRO\": \"aws_distro\",\n      \"OTEL_PYTHON_CONFIGURATOR\": \"aws_configurator\",\n      \"OTEL_SDK_DISABLED\": \"false\",\n      \"OTEL_EXPORTER_OTLP_PROTOCOL\": \"http/protobuf\",\n      \"OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\",\n      \"OTEL_PYTHON_LOG_AUTO_INSTRUMENTATION\": \"true\"\n    },\n    \"version\": \"0.21.0\"\n  },\n  {\n    \"name\": \"nodejs-lambda-adot\",\n    \"displayName\": \"Nodejs Lambda AWS ADOT\",\n    \"language\": \"nodejs\",\n    \"isDefault\": false,\n    \"execWrapper\": \"/opt/otel-instrument\",\n    \"artifact\": \"adot-nodejs\",\n    \"applicationSignals\": false,\n    \"compatibleRuntimes\": [\n      \"nodejs18.x\",\n      \"nodejs20.x\",\n      \"nodejs22.x\",\n      \"nodejs24.x\"\n    ],\n    \"environment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_ENABLED\": \"false\"\n    },\n    \"bootstrapEnvironment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_RUNTIME_ENABLED\": \"false\",\n      \"OTEL_AWS_LAMBDA_FAST_START\": \"false\",\n      \"OTEL_PROPAGATORS\": \"tracecontext,baggage\",\n      \"OTEL_EXPORTER_OTLP_TRACES_ENDPOINT\": \"http://localhost:4318/v1/traces\",\n      \"OTEL_EXPORTER_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_EXPORTER_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\",\n      \"OTEL_NODE_DISABLED_INSTRUMENTATIONS\": \"none\",\n      \"OTEL_NODE_ENABLED_INSTRUMENTATIONS\": \"amqplib,aws-lambda,aws-sdk,bunyan,cassandra-driver,connect,cucumber,dataloader,dns,express,fs,generic-pool,graphql,grpc,hapi,host-metrics,http,ioredis,kafkajs,knex,koa,lru-memoizer,memcached,mongodb,mongoose,mysql2,mysql,nestjs-core,net,openai,oracledb,pg,pino,redis,restify,router,runtime-node,socket.io,tedious,undici,winston\",\n      \"OTEL_SDK_DISABLED\": \"false\",\n      \"OTEL_EXPORTER_OTLP_PROTOCOL\": \"http/protobuf\",\n      \"OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\"\n    },\n    \"version\": \"0.13.0\"\n  },\n  {\n    \"name\": \"nodejs-lambda-adot-application-signals\",\n    \"displayName\": \"Nodejs Lambda AWS ADOT + Application Signals\",\n    \"language\": \"nodejs\",\n    \"isDefault\": false,\n    \"execWrapper\": \"/opt/otel-instrument\",\n    \"artifact\": \"adot-nodejs\",\n    \"applicationSignals\": true,\n    \"compatibleRuntimes\": [\n      \"nodejs18.x\",\n      \"nodejs20.x\",\n      \"nodejs22.x\",\n      \"nodejs24.x\"\n    ],\n    \"environment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_ENABLED\": \"true\"\n    },\n    \"bootstrapEnvironment\": {\n      \"OTEL_AWS_APPLICATION_SIGNALS_RUNTIME_ENABLED\": \"false\",\n      \"OTEL_AWS_LAMBDA_FAST_START\": \"false\",\n      \"OTEL_PROPAGATORS\": \"tracecontext,baggage\",\n      \"OTEL_EXPORTER_OTLP_TRACES_ENDPOINT\": \"http://localhost:4318/v1/traces\",\n      \"OTEL_EXPORTER_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_EXPORTER_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\",\n      \"OTEL_NODE_DISABLED_INSTRUMENTATIONS\": \"none\",\n      \"OTEL_NODE_ENABLED_INSTRUMENTATIONS\": \"amqplib,aws-lambda,aws-sdk,bunyan,cassandra-driver,connect,cucumber,dataloader,dns,express,fs,generic-pool,graphql,grpc,hapi,host-metrics,http,ioredis,kafkajs,knex,koa,lru-memoizer,memcached,mongodb,mongoose,mysql2,mysql,nestjs-core,net,openai,oracledb,pg,pino,redis,restify,router,runtime-node,socket.io,tedious,undici,winston\",\n      \"OTEL_SDK_DISABLED\": \"false\",\n      \"OTEL_EXPORTER_OTLP_PROTOCOL\": \"http/protobuf\",\n      \"OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_METRICS_ENDPOINT\": \"http://localhost:4318/v1/metrics\",\n      \"OTEL_AWS_OTLP_LOGS_ENDPOINT\": \"http://localhost:4318/v1/logs\"\n    },\n    \"version\": \"0.13.0\"\n  }\n] as const;\n"]}

package/lib/generated/fargate.d.ts

@@ -4,13 +4,13 @@
  * Produced by cdk/scripts/generate.ts from artifacts.json and manifest/layers.json.
  * Run `npm run generate` (or `npm run build`) to refresh it.
  *
- * Odigos artifact version: v0.0.20
+ * Odigos artifact version: v0.0.22
  */
 /**
  * The multi-arch agents bundle the staging container copies from, at the tag this package's release
  * published. Empty before the first release.
  */
-export declare const FARGATE_AGENTS_IMAGE = "registry.odigos.io/odigos-fargate-agents:v0.0.20";
+export declare const FARGATE_AGENTS_IMAGE = "registry.odigos.io/odigos-fargate-agents:v0.0.22";
 /** Shared task-volume mount path the language agents are staged into, in every container. */
 export declare const FARGATE_AGENTS_DIR = "/var/odigos";
 /** Where the agents bundle holds the agent files; the staging container copies from here to there. */