@aws/nx-plugin 0.64.1 → 0.65.0

package/src/ts/strands-agent/files/app/agent-core-mcp-client.ts.template

@@ -0,0 +1,132 @@
+import { McpClient } from '@strands-agents/sdk';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { AwsClient } from 'aws4fetch';
+import { fromNodeProviderChain } from '@aws-sdk/credential-providers';
+
+/**
+ * Options for creating an AgentCore MCP client with IAM authentication
+ */
+export interface AgentCoreMcpClientIamOptions {
+  agentRuntimeArn: string;
+  region: string;
+  sessionId: string;
+}
+
+/**
+ * Options for creating an AgentCore MCP client with JWT authentication
+ */
+export interface AgentCoreMcpClientJwtOptions {
+  agentRuntimeArn: string;
+  accessToken: string;
+  region: string;
+  sessionId: string;
+}
+
+/**
+ * Internal options for creating an AgentCore MCP client
+ */
+interface CreateOptions {
+  agentRuntimeArn: string;
+  region: string;
+  sessionId: string;
+  additionalHeaders?: Record<string, string>;
+  fetch?: typeof fetch;
+}
+
+/**
+ * Factory for clients to call MCP servers hosted on Bedrock AgentCore Runtime
+ */
+export class AgentCoreMcpClient {
+  /**
+   * Internal method to create an MCP client
+   */
+  private static create(options: CreateOptions): McpClient {
+    const {
+      agentRuntimeArn,
+      region,
+      sessionId,
+      additionalHeaders = {},
+      fetch: customFetch,
+    } = options;
+
+    // Encode the ARN for URL
+    const encodedArn = agentRuntimeArn
+      .replace(/:/g, '%3A')
+      .replace(/\//g, '%2F');
+    const url = `https://bedrock-agentcore.${region}.amazonaws.com/runtimes/${encodedArn}/invocations?qualifier=DEFAULT`;
+
+    // Create a custom fetch that adds required headers
+    const fetchWithHeaders: typeof fetch = async (input, init) => {
+      const headers = {
+        'X-Amzn-Bedrock-AgentCore-Runtime-Session-Id': sessionId,
+        ...additionalHeaders,
+      };
+      const existingHeaders = init?.headers;
+
+      const mergedInit = {
+        ...init,
+        headers: !existingHeaders
+          ? headers
+          : existingHeaders instanceof Headers
+            ? (() => {
+                const h = new Headers(existingHeaders);
+                Object.entries(headers).forEach(([k, v]) => h.append(k, v));
+                return h;
+              })()
+            : Array.isArray(existingHeaders)
+              ? [...existingHeaders, ...Object.entries(headers)]
+              : { ...existingHeaders, ...headers },
+      };
+      return (customFetch || fetch)(input, mergedInit);
+    };
+
+    // Create the transport
+    const transport = new StreamableHTTPClientTransport(new URL(url), {
+      fetch: fetchWithHeaders,
+    });
+
+    // Create and return the MCP client
+    return new McpClient({ transport });
+  }
+
+  /**
+   * Create an MCP client with IAM (SigV4) authentication
+   */
+  static withIamAuth(options: AgentCoreMcpClientIamOptions): McpClient {
+    const { region, ...rest } = options;
+
+    // Create credential provider
+    const credentialProvider = fromNodeProviderChain();
+
+    // Create a SigV4 signing fetch function
+    const sigv4Fetch: typeof fetch = async (...args) => {
+      const credentials = await credentialProvider();
+      const client = new AwsClient({
+        ...credentials,
+        service: 'bedrock-agentcore',
+        region,
+      });
+      return client.fetch(...args);
+    };
+
+    return AgentCoreMcpClient.create({
+      ...rest,
+      region,
+      fetch: sigv4Fetch,
+    });
+  }
+
+  /**
+   * Create an MCP client with JWT authentication
+   */
+  static withJwtAuth(options: AgentCoreMcpClientJwtOptions): McpClient {
+    const { accessToken, ...rest } = options;
+
+    return AgentCoreMcpClient.create({
+      ...rest,
+      additionalHeaders: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+  }
+}

package/src/ts/strands-agent/files/app/agent-core-trpc-client.ts.template

@@ -0,0 +1,124 @@
+import { fromNodeProviderChain } from '@aws-sdk/credential-providers';
+import { createTRPCClient, createWSClient, WebSocketLinkOptions, wsLink } from '@trpc/client';
+import { AwsClient } from 'aws4fetch';
+import { AnyTRPCRouter } from '@trpc/server';
+import { WebSocket } from 'node:http';
+
+export interface WebSocketTrpcClientOptions {
+  /**
+   * URL of the websocket server, eg http://localhost:8080/ws
+   */
+  url: string;
+  /**
+   * Factory for creating headers to include in the WebSocket handshake
+   */
+  buildHeaders?: () => Promise<{ [key: string]: string }>;
+}
+
+/**
+ * Client for connecting to tRPC APIs via WebSocket
+ */
+export class WebSocketTrpcClient {
+  /**
+   * Utility for creating a tRPC client with a WebSocket link and custom headers
+   */
+  public static create = <TRouter extends AnyTRPCRouter>({
+    url,
+    buildHeaders = async () => ({}),
+  }: WebSocketTrpcClientOptions) => {
+    let headers = {};
+    const client = createWSClient({
+      url: async () => {
+        headers = await buildHeaders();
+        return url;
+      },
+      WebSocket: class extends WebSocket {
+        constructor(wsUrl: string | URL) {
+          super(wsUrl, { headers });
+        }
+      } as any,
+    });
+
+    return createTRPCClient<TRouter>({
+      links: [wsLink({ client } as WebSocketLinkOptions<TRouter>)],
+    });
+  };
+}
+
+export interface AgentCoreTrpcClientOptions {
+  /**
+   * The ARN of the Bedrock AgentCore Runtime to connect to
+   */
+  agentRuntimeArn: string;
+}
+
+export interface AgentCoreTrpcClientIamOptions extends AgentCoreTrpcClientOptions {
+  /**
+   * Optional AWS credential provider. If not provided, uses the default
+   * credential provider chain from the AWS SDK.
+   */
+  credentialProvider?: ReturnType<typeof fromNodeProviderChain>;
+}
+
+export interface AgentCoreTrpcClientJwtOptions extends AgentCoreTrpcClientOptions {
+  /**
+   * A function which returns the JWT access token used to authenticate
+   */
+  accessTokenProvider: () => Promise<string>;
+}
+
+/**
+ * Client for connecting to a tRPC API on Bedrock AgentCore Runtime via WebSocket.
+ */
+export class AgentCoreTrpcClient {
+  /**
+   * Construct the websocket url for connecting to Bedrock AgentCore Runtime
+   */
+  private static buildUrl = (agentRuntimeArn: string) => {
+    const region = agentRuntimeArn.split(':')[3];
+    const url = `wss://bedrock-agentcore.${region}.amazonaws.com/runtimes/${agentRuntimeArn.replace(/:/g, '%3A').replace(/\//g, '%2F')}/ws`;
+    return { region, url };
+  };
+
+  /**
+   * Creates a tRPC client with IAM authentication using AWS credentials.
+   *
+   * The WebSocket connection is authenticated using AWS Signature Version 4 (SigV4) signed headers.
+   * This method signs the WebSocket upgrade request headers directly, rather than using a presigned URL.
+   */
+  public static withIamAuth = <TRouter extends AnyTRPCRouter>(options: AgentCoreTrpcClientIamOptions) => {
+    const credentialProvider =
+      options.credentialProvider ?? fromNodeProviderChain();
+    const { region, url } = AgentCoreTrpcClient.buildUrl(options.agentRuntimeArn);
+
+    return WebSocketTrpcClient.create<TRouter>({
+      url,
+      buildHeaders: async () =>
+        Object.fromEntries(
+          (
+            await new AwsClient({
+              ...(await credentialProvider()),
+              region,
+              service: 'bedrock-agentcore',
+            }).sign(url)
+          ).headers,
+        ),
+    });
+  };
+
+  /**
+   * Creates a tRPC client with JWT (JSON Web Token) authentication.
+   *
+   * The WebSocket connection includes the JWT as a Bearer token in the Authorization header.
+   */
+  public static withJwtAuth = <TRouter extends AnyTRPCRouter>(options: AgentCoreTrpcClientJwtOptions) => {
+    const { url } = AgentCoreTrpcClient.buildUrl(options.agentRuntimeArn);
+
+    return WebSocketTrpcClient.create<TRouter>({
+      url,
+      buildHeaders: async () => ({
+        Authorization: `Bearer ${await options.accessTokenProvider()}`,
+      }),
+    });
+  };
+}

package/src/ts/strands-agent/files/app/agent.ts.template

@@ -0,0 +1,20 @@
+import { Agent, tool } from '@strands-agents/sdk';
+import { z } from 'zod';
+
+const add = tool({
+  name: 'Add',
+  description: 'Add two numbers',
+  inputSchema: z.object({
+    a: z.number(),
+    b: z.number(),
+  }),
+  callback: ({ a, b }) => a + b,
+});
+
+export const getAgent = () =>
+  new Agent({
+    systemPrompt: `You are an addition wizard.
+  Use the add tool for addition tasks.
+  Refer to tools as your 'spellbook'.`,
+    tools: [add],
+  });

package/src/ts/strands-agent/files/app/client.ts.template

@@ -0,0 +1,28 @@
+import { AppRouter } from './router.js';
+import { AgentCoreTrpcClient, WebSocketTrpcClient } from './agent-core-trpc-client.js';
+
+/**
+ * Client for connecting to <%- agentNameClassName %> on Bedrock AgentCore Runtime via WebSocket from a NodeJS environment
+ *
+ * Refer to the Nx Plugin for AWS documentation for instructions to connect to this agent in a browser.
+ */
+export class <%- agentNameClassName %>Client {
+  /**
+   * Creates a tRPC client with IAM authentication using AWS credentials.
+   *
+   * The WebSocket connection is authenticated using AWS Signature Version 4 (SigV4)
+   */
+  public static withIamAuth = AgentCoreTrpcClient.withIamAuth<AppRouter>;
+
+  /**
+   * Creates a tRPC client with JWT (JSON Web Token) authentication.
+   *
+   * The WebSocket connection includes the JWT as a Bearer token in the Authorization header.
+   */
+  public static withJwtAuth = AgentCoreTrpcClient.withJwtAuth<AppRouter>;
+
+  /**
+   * Creates a tRPC client for use with a locally running <%- agentNameClassName %>.
+   */
+  public static local = WebSocketTrpcClient.create<AppRouter>;
+}

package/src/ts/strands-agent/files/app/index.ts.template

@@ -0,0 +1,54 @@
+import { createServer } from 'http';
+import {
+  CreateHTTPContextOptions,
+  createHTTPHandler,
+} from '@trpc/server/adapters/standalone';
+import { appRouter, AppRouter } from './router.js';
+import { WebSocketServer } from 'ws';
+import cors from 'cors';
+import {
+  CreateWSSContextFnOptions,
+  applyWSSHandler,
+} from '@trpc/server/adapters/ws';
+import { Context } from './init.js';
+
+const PORT = parseInt(process.env.PORT || '8080');
+
+const createContext = (
+  opts: CreateHTTPContextOptions | CreateWSSContextFnOptions,
+): Context => ({});
+
+const handler = createHTTPHandler({
+  router: appRouter,
+  middleware: cors(),
+  createContext,
+});
+
+const server = createServer((req, res) => {
+  const url = new URL(req.url || '', `https://${req.headers.host}`);
+
+  // Handle bedrock agentcore health check
+  if (url.pathname === '/ping') {
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.end('Healthy');
+    return;
+  }
+
+  // Handle other requests with tRPC
+  handler(req, res);
+});
+
+const wss = new WebSocketServer({
+  server,
+  path: '/ws',
+});
+
+applyWSSHandler<AppRouter>({
+  wss,
+  router: appRouter,
+  createContext,
+});
+
+server.listen(PORT);
+
+console.log(`TRPC server listening on port ${PORT}`);

package/src/ts/strands-agent/files/app/init.ts.template

@@ -0,0 +1,8 @@
+import { initTRPC } from '@trpc/server';
+
+// eslint-disable-next-line
+export interface Context {}
+
+export const t = initTRPC.context<Context>().create();
+
+export const publicProcedure = t.procedure;

package/src/ts/strands-agent/files/app/router.ts.template

@@ -0,0 +1,34 @@
+import { publicProcedure, t } from './init.js';
+import { z } from 'zod';
+import { zAsyncIterable } from './schema/z-async-iterable.js';
+import { getAgent } from './agent.js';
+
+export const router = t.router;
+
+export const appRouter = router({
+  invoke: publicProcedure
+    .input(z.object({ message: z.string() }))
+    .output(
+      zAsyncIterable({
+        yield: z.string(),
+        tracked: false,
+      }),
+    )
+    .subscription(async function* (opts) {
+      const agent = getAgent();
+
+      for await (const event of agent.stream(opts.input.message)) {
+        if (
+          event.type === 'modelContentBlockDeltaEvent' &&
+          event.delta.type === 'textDelta'
+        ) {
+          yield event.delta.text;
+        } else if (event.type === 'modelMessageStopEvent') {
+          yield '\n';
+        }
+      }
+      return;
+    }),
+});
+
+export type AppRouter = typeof appRouter;

package/src/ts/strands-agent/files/app/schema/z-async-iterable.ts.template

@@ -0,0 +1,77 @@
+import { isTrackedEnvelope, tracked, TrackedEnvelope } from '@trpc/server';
+import { z } from 'zod';
+
+function isAsyncIterable<TValue, TReturn = unknown>(
+  value: unknown,
+): value is AsyncIterable<TValue, TReturn> {
+  return !!value && typeof value === 'object' && Symbol.asyncIterator in value;
+}
+
+const trackedEnvelopeSchema =
+  z.custom<TrackedEnvelope<unknown>>(isTrackedEnvelope);
+
+/**
+ * A Zod schema helper designed specifically for validating async iterables. This schema ensures that:
+ * 1. The value being validated is an async iterable.
+ * 2. Each item yielded by the async iterable conforms to a specified type.
+ * 3. The return value of the async iterable, if any, also conforms to a specified type.
+ */
+export function zAsyncIterable<
+  TYieldIn,
+  TYieldOut,
+  TReturnIn = void,
+  TReturnOut = void,
+  Tracked extends boolean = false,
+>(opts: {
+  /**
+   * Validate the value yielded by the async generator
+   */
+  yield: z.ZodType<TYieldOut, TYieldIn>;
+  /**
+   * Validate the return value of the async generator
+   * @remark not applicable for subscriptions
+   */
+  return?: z.ZodType<TReturnOut, TReturnIn>;
+  /**
+   * Whether if the yielded values are tracked
+   * @remark only applicable for subscriptions
+   */
+  tracked?: Tracked;
+}) {
+  return z
+    .custom<
+      AsyncIterable<
+        Tracked extends true ? TrackedEnvelope<TYieldIn> : TYieldIn,
+        TReturnIn
+      >
+    >((val) => isAsyncIterable(val))
+    .transform(async function* (iter) {
+      const iterator = iter[Symbol.asyncIterator]();
+      try {
+        let next;
+        while ((next = await iterator.next()) && !next.done) {
+          if (opts.tracked) {
+            const [id, data] = trackedEnvelopeSchema.parse(next.value);
+            yield tracked(id, await opts.yield.parseAsync(data));
+            continue;
+          }
+          yield opts.yield.parseAsync(next.value);
+        }
+        if (opts.return) {
+          return await opts.return.parseAsync(next.value);
+        }
+        return;
+      } finally {
+        await iterator.return?.();
+      }
+    }) as z.ZodType<
+    AsyncIterable<
+      Tracked extends true ? TrackedEnvelope<TYieldIn> : TYieldIn,
+      TReturnIn
+    >,
+    AsyncIterable<
+      Tracked extends true ? TrackedEnvelope<TYieldOut> : TYieldOut,
+      TReturnOut
+    >
+  >;
+}

package/src/ts/strands-agent/files/deploy/Dockerfile.template

@@ -0,0 +1,16 @@
+FROM public.ecr.aws/docker/library/node:lts-jod
+
+WORKDIR /app
+
+# Add AWS Distro for OpenTelemetry for observability
+# https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/observability-configure.html
+RUN npm install @aws/aws-distro-opentelemetry-node-autoinstrumentation@^0.7.0
+
+# Copy bundled agent
+COPY --from=workspace <%- distDir %>/bundle/agent/<%- name %>/index.js /app
+
+EXPOSE 8080
+
+# Auto-instrument with AWS Distro for OpenTelemetry
+# https://aws-otel.github.io/docs/getting-started/js-sdk/trace-metric-auto-instr
+CMD [ "node", "--require", "@aws/aws-distro-opentelemetry-node-autoinstrumentation/register", "index.js" ]

package/src/ts/strands-agent/generator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import { TsStrandsAgentGeneratorSchema } from './schema';
+import { NxGeneratorInfo } from '../../utils/nx';
+export declare const TS_STRANDS_AGENT_GENERATOR_INFO: NxGeneratorInfo;
+export declare const tsStrandsAgentGenerator: (tree: Tree, options: TsStrandsAgentGeneratorSchema) => Promise<GeneratorCallback>;
+export default tsStrandsAgentGenerator;

package/src/ts/strands-agent/generator.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsStrandsAgentGenerator = exports.TS_STRANDS_AGENT_GENERATOR_INFO = void 0;
+const tslib_1 = require("tslib");
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const devkit_1 = require("@nx/devkit");
+const nx_1 = require("../../utils/nx");
+const metrics_1 = require("../../utils/metrics");
+const format_1 = require("../../utils/format");
+const names_1 = require("../../utils/names");
+const versions_1 = require("../../utils/versions");
+const npm_scope_1 = require("../../utils/npm-scope");
+const bundle_1 = require("../../utils/bundle/bundle");
+const iac_1 = require("../../utils/iac");
+const shared_constructs_1 = require("../../utils/shared-constructs");
+const agent_core_constructs_1 = require("../../utils/agent-core-constructs/agent-core-constructs");
+const port_1 = require("../../utils/port");
+exports.TS_STRANDS_AGENT_GENERATOR_INFO = (0, nx_1.getGeneratorInfo)(__filename);
+const tsStrandsAgentGenerator = (tree, options) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const project = (0, nx_1.readProjectConfigurationUnqualified)(tree, options.project);
+    if (!tree.exists((0, devkit_1.joinPathFragments)(project.root, 'tsconfig.json'))) {
+        throw new Error(`Unsupported project ${options.project}. Expected a TypeScript project (with a tsconfig.json)`);
+    }
+    const defaultName = `${(0, names_1.kebabCase)(project.name.split('/').pop())}-agent`;
+    const name = (0, names_1.kebabCase)((_a = options.name) !== null && _a !== void 0 ? _a : defaultName);
+    const agentNameClassName = (0, names_1.toClassName)(name);
+    const agentTargetPrefix = options.name ? name : 'agent';
+    const targetSourceDirRelativeToProjectRoot = (0, devkit_1.joinPathFragments)('src', agentTargetPrefix);
+    const targetSourceDir = (0, devkit_1.joinPathFragments)(project.root, targetSourceDirRelativeToProjectRoot);
+    const relativeSourceDir = targetSourceDir.replace(project.root + '/', './');
+    const distDir = (0, devkit_1.joinPathFragments)('dist', project.root);
+    const computeType = (_b = options.computeType) !== null && _b !== void 0 ? _b : 'BedrockAgentCoreRuntime';
+    // Generate example agent
+    (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, 'files', 'app'), targetSourceDir, {
+        name,
+        agentNameClassName,
+        distDir,
+    }, { overwriteStrategy: devkit_1.OverwriteStrategy.KeepExisting });
+    if (computeType === 'BedrockAgentCoreRuntime') {
+        const dockerImageTag = `${(0, npm_scope_1.getNpmScope)(tree)}-${name}:latest`;
+        // Add bundle target
+        (0, bundle_1.addTypeScriptBundleTarget)(tree, project, {
+            targetFilePath: `${targetSourceDirRelativeToProjectRoot}/index.ts`,
+            bundleOutputDir: (0, devkit_1.joinPathFragments)('agent', name),
+        });
+        // Add the Dockerfile
+        (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, 'files', 'deploy'), targetSourceDir, {
+            distDir,
+            name,
+        }, { overwriteStrategy: devkit_1.OverwriteStrategy.KeepExisting });
+        const dockerTargetName = `${agentTargetPrefix}-docker`;
+        project.targets[dockerTargetName] = {
+            cache: true,
+            executor: 'nx:run-commands',
+            options: {
+                command: `docker build --platform linux/arm64 -t ${dockerImageTag} ${targetSourceDir} --build-context workspace=.`,
+            },
+            dependsOn: ['bundle'],
+        };
+        (0, nx_1.addDependencyToTargetIfNotPresent)(project, 'docker', dockerTargetName);
+        (0, nx_1.addDependencyToTargetIfNotPresent)(project, 'build', 'docker');
+        // Add shared constructs
+        const iacProvider = yield (0, iac_1.resolveIacProvider)(tree, options.iacProvider);
+        yield (0, shared_constructs_1.sharedConstructsGenerator)(tree, { iacProvider });
+        (0, agent_core_constructs_1.addAgentInfra)(tree, {
+            agentNameKebabCase: name,
+            agentNameClassName,
+            projectName: project.name,
+            dockerImageTag,
+            iacProvider,
+        });
+    }
+    // Add dependencies
+    (0, devkit_1.addDependenciesToPackageJson)(tree, (0, versions_1.withVersions)([
+        '@trpc/server',
+        '@trpc/client',
+        'zod',
+        '@strands-agents/sdk',
+        'ws',
+        'cors',
+        '@aws-sdk/credential-providers',
+        'aws4fetch',
+        '@modelcontextprotocol/sdk',
+    ]), (0, versions_1.withVersions)(['tsx', '@types/ws', '@types/cors']));
+    // NB: we assign the local dev port from 8081 as 8080 is used by vscode server, and so conflicts
+    // for those working on remote dev envirionments. The deployed agent in agentcore still runs on
+    // 8080 as per the agentcore contract.
+    const localDevPort = (0, port_1.assignPort)(tree, project, 8081);
+    (0, devkit_1.updateProjectConfiguration)(tree, project.name, Object.assign(Object.assign({}, project), { targets: Object.assign(Object.assign({}, project.targets), { [`${agentTargetPrefix}-serve`]: {
+                executor: 'nx:run-commands',
+                options: {
+                    commands: [`tsx --watch ${relativeSourceDir}/index.ts`],
+                    cwd: '{projectRoot}',
+                    env: {
+                        PORT: `${localDevPort}`,
+                    },
+                },
+                continuous: true,
+            } }) }));
+    (0, nx_1.addComponentGeneratorMetadata)(tree, project.name, exports.TS_STRANDS_AGENT_GENERATOR_INFO, agentTargetPrefix, { port: localDevPort });
+    yield (0, metrics_1.addGeneratorMetricsIfApplicable)(tree, [
+        exports.TS_STRANDS_AGENT_GENERATOR_INFO,
+    ]);
+    yield (0, format_1.formatFilesInSubtree)(tree);
+    return () => {
+        (0, devkit_1.installPackagesTask)(tree);
+    };
+});
+exports.tsStrandsAgentGenerator = tsStrandsAgentGenerator;
+exports.default = exports.tsStrandsAgentGenerator;
+//# sourceMappingURL=generator.js.map

package/src/ts/strands-agent/generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.js","sourceRoot":"","sources":["../../../../../../packages/nx-plugin/src/ts/strands-agent/generator.ts"],"names":[],"mappings":"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"}

package/src/ts/strands-agent/schema.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { IacProviderOption } from '../../utils/iac';
+
+export type TsStrandsAgentComputeType = 'BedrockAgentCoreRuntime' | 'None';
+
+export interface TsStrandsAgentGeneratorSchema {
+  project: string;
+  name?: string;
+  computeType?: TsStrandsAgentComputeType;
+  iacProvider: IacProviderOption;
+}