@looopy-ai/aws 1.0.1

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025 Greg Bacchus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,156 @@
+# @looopy-ai/aws
+
+AWS helpers for running Looopy AgentCore inside AWS runtimes. This package currently ships a DynamoDB-backed `AgentStore` plus the `agentcore-runtime-server` used to service Bedrock AgentCore Runtime events.
+
+## DynamoDB Agent Store
+
+`DynamoDBAgentStore` persists each AgentCore context in DynamoDB. A single table can host many agents by prefixing the keys:
+
+- Partition key (`pk` by default): `agent#{agentId}`
+- Sort key (`sk` by default): `context#{contextId}`
+- Attributes: `entityType`, serialized `state`, and an ISO `updatedAt`
+
+You can override the key attribute names and prefixes in the constructor to match an existing schema.
+
+### Usage
+
+```ts
+import { Agent } from '@looopy-ai/core';
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
+import { DynamoDBAgentStore } from '@looopy-ai/aws/ts/stores';
+
+const documentClient = DynamoDBDocumentClient.from(
+  new DynamoDBClient({ region: process.env.AWS_REGION }),
+);
+
+const agentStore = new DynamoDBAgentStore({
+  tableName: process.env.AGENT_STATE_TABLE!,
+  agentId: 'agentcore-runtime',
+  documentClient,
+});
+
+const agent = new Agent({
+  agentId: 'agentcore-runtime',
+  contextId: 'ctx-1234',
+  agentStore,
+  // supply llmProvider, toolProviders, and messageStore
+});
+```
+
+### Creating the table with AWS CDK
+
+The snippet below provisions a table that matches the defaults used by `DynamoDBAgentStore`.
+
+```ts
+import { Stack, StackProps, RemovalPolicy, CfnOutput } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import { AttributeType, BillingMode, Table } from 'aws-cdk-lib/aws-dynamodb';
+
+export class AgentStateStoreStack extends Stack {
+  public readonly table: Table;
+
+  constructor(scope: Construct, id: string, props?: StackProps) {
+    super(scope, id, props);
+
+    this.table = new Table(this, 'AgentStateTable', {
+      partitionKey: { name: 'pk', type: AttributeType.STRING },
+      sortKey: { name: 'sk', type: AttributeType.STRING },
+      billingMode: BillingMode.PAY_PER_REQUEST,
+      pointInTimeRecovery: true,
+      removalPolicy: RemovalPolicy.RETAIN,
+    });
+
+    new CfnOutput(this, 'AgentStateTableName', { value: this.table.tableName });
+  }
+}
+```
+
+1. Run `cdk init app --language typescript` in a new directory.
+2. Add the stack above to `lib/agent-state-store-stack.ts` and synthesize with `cdk synth`.
+3. Deploy with `cdk deploy` and capture the `AgentStateTableName` output.
+4. Pass the table name to your runtime as `AGENT_STATE_TABLE` and grant the runtime IAM role `dynamodb:GetItem`, `PutItem`, and `DeleteItem` actions for that table.
+
+> Optional: add `timeToLiveAttribute: 'ttl'` to the table props and write a UNIX timestamp to that attribute from your runtime if you want DynamoDB TTL based cleanup.
+
+### Wiring into AgentCore Runtime Server
+
+When running the provided `agentcore-runtime-server`, create the store once and reuse it for each invocation:
+
+```ts
+import { serve } from '@looopy-ai/aws';
+import { Agent } from '@looopy-ai/core';
+import { DynamoDBAgentStore } from '@looopy-ai/aws/ts/stores';
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
+
+const documentClient = DynamoDBDocumentClient.from(new DynamoDBClient({ region: process.env.AWS_REGION }));
+const agentStore = new DynamoDBAgentStore({
+  tableName: process.env.AGENT_STATE_TABLE!,
+  agentId: 'agentcore-runtime',
+  documentClient,
+});
+
+serve({
+  agent: async (contextId) =>
+    new Agent({
+      agentId: 'agentcore-runtime',
+      contextId,
+      agentStore,
+      // other dependencies here
+    }),
+});
+```
+
+This ensures each Bedrock AgentCore request can resume from the state stored in DynamoDB across separate Lambda or container invocations.
+
+## AgentCore Memory Message Store
+
+`AgentCoreMemoryMessageStore` streams conversation turns to the Bedrock AgentCore Memory APIs so short-term and long-term memories persist outside of your runtime container. The store wraps the runtime (`CreateEvent`, `ListEvents`, `DeleteEvent`) and memory retrieval APIs (`RetrieveMemoryRecords`) and implements the `MessageStore` contract used by `Agent`.
+
+### Prerequisites
+
+1. In the AWS Console open **Amazon Bedrock → Agentic Memory** (or use the `@aws-sdk/client-bedrock-agentcore` / AWS CLI equivalent) and create a Memory resource. Enable the strategies you want (summaries, user preferences, etc.).
+2. Capture the `memoryId` that is returned.
+3. Grant the runtime IAM role the following permissions scoped to that memory: `bedrock:CreateEvent`, `bedrock:ListEvents`, `bedrock:DeleteEvent`, and `bedrock:RetrieveMemoryRecords`.
+4. Provide an `agentId` that serves as the actor identifier for all sessions. This typically represents the agent or assistant identity.
+
+### Usage
+
+```ts
+import { Agent } from '@looopy-ai/core';
+import { AgentCoreMemoryMessageStore } from '@looopy-ai/aws/ts/stores';
+
+const messageStore = new AgentCoreMemoryMessageStore({
+  memoryId: process.env.AGENT_MEMORY_ID!,
+  agentId: 'agentcore-runtime',
+  region: process.env.AWS_REGION,
+  // Optional: enable long-term memory retrieval
+  longTermMemoryNamespace: 'persistent-context',
+});
+
+const agent = new Agent({
+  agentId: 'agentcore-runtime',
+  contextId: 'ctx-1234',
+  messageStore,
+  // llmProvider, toolProviders, agentStore, etc.
+});
+```
+
+### Features
+
+- **Short-term memory:** Every call to `append` persists conversation turns via `CreateEventCommand`. Messages are stored per session (`contextId`).
+- **Long-term memory (optional):** When `longTermMemoryNamespace` is configured, `getRecent` automatically retrieves and prepends relevant long-term memories to the conversation context.
+- **Token budget support:** `getRecent` honors token limits using `trimToTokenBudget` to keep conversations within model constraints.
+- **Memory search:** Use `searchMemories(query, options?)` to retrieve long-term memories semantically related to a query.
+- **Session cleanup:** Call `clear(contextId)` to remove all short-term events for a specific session. Long-term memories persist per your memory resource configuration.
+
+### Configuration Options
+
+| Option | Required | Description |
+|--------|----------|-------------|
+| `memoryId` | Yes | Pre-provisioned AgentCore memory identifier |
+| `agentId` | Yes | Static actor identifier used across all sessions |
+| `region` | No | AWS region (defaults to `AWS_REGION` env var or `us-west-2`) |
+| `client` | No | Custom `BedrockAgentCoreClient` instance (useful for testing) |
+| `longTermMemoryNamespace` | No | Namespace for retrieving long-term memories. When set, enables automatic memory retrieval in `getRecent` |

package/dist/agentcore-runtime-server.d.ts

@@ -0,0 +1,14 @@
+import { type Agent, type AuthContext } from '@looopy-ai/core';
+import type pino from 'pino';
+type ServeConfig = {
+    agent: (contextId: string) => Promise<Agent>;
+    decodeAuthorization?: (authorization: string) => Promise<AuthContext | null>;
+    port?: number;
+};
+declare module 'hono' {
+    interface ContextVariableMap {
+        logger: pino.Logger;
+    }
+}
+export declare const serve: (config: ServeConfig) => void;
+export {};

package/dist/agentcore-runtime-server.js

@@ -0,0 +1,113 @@
+import { serve as serveNodeJs } from '@hono/node-server';
+import { getLogger } from '@looopy-ai/core';
+import { SSEServer } from '@looopy-ai/core/ts';
+import { Hono } from 'hono';
+import { requestId } from 'hono/request-id';
+import { pinoHttp } from 'pino-http';
+import { z } from 'zod';
+const promptValidator = z.object({
+    prompt: z.string().min(1),
+});
+export const serve = (config) => {
+    const app = new Hono();
+    app.use(requestId());
+    app.use(async (c, next) => {
+        c.env.incoming.id = c.var.requestId;
+        await new Promise((resolve) => pinoHttp({ logger: getLogger({}) })(c.env.incoming, c.env.outgoing, () => resolve(undefined)));
+        c.set('logger', c.env.incoming.log);
+        await next();
+    });
+    const state = { busy: false, agent: undefined };
+    app.get('/ping', async (c) => {
+        return c.text(JSON.stringify({
+            status: state.busy ? 'HealthyBusy' : 'Healthy',
+            time_of_last_update: Date.now(),
+        }));
+    });
+    app.post('/invocation', async (c) => {
+        const logger = c.var.logger;
+        if (state.busy) {
+            return c.json({ error: 'Agent is currently busy' }, 503);
+        }
+        state.busy = true;
+        const contextId = c.req.header('X-Amzn-Bedrock-AgentCore-Runtime-Session-Id') || undefined;
+        if (!contextId) {
+            state.busy = false;
+            return c.json({ error: 'Missing X-Amzn-Bedrock-AgentCore-Runtime-Session-Id header' }, 400);
+        }
+        const authorization = c.req.header('Authorization') || undefined;
+        if (!authorization && config.decodeAuthorization) {
+            state.busy = false;
+            return c.json({ error: 'Missing Authorization header' }, 401);
+        }
+        const authContext = await getAuthContext(authorization, config.decodeAuthorization);
+        if (config.decodeAuthorization && !authContext) {
+            state.busy = false;
+            return c.json({ error: 'Forbidden' }, 403);
+        }
+        if (!state.agent) {
+            state.agent = await config.agent(contextId);
+            logger.info({ contextId }, 'Created new agent instance');
+        }
+        const agent = state.agent;
+        if (agent.contextId !== contextId) {
+            state.busy = false;
+            return c.json({ error: 'Another session is active' }, 409);
+        }
+        const body = await c.req.json();
+        const promptValidation = promptValidator.safeParse(body);
+        if (!promptValidation.success) {
+            state.busy = false;
+            return c.json({ error: 'Invalid prompt', details: promptValidation.error.issues }, 400);
+        }
+        const { prompt } = promptValidation.data;
+        const sseServer = new SSEServer();
+        const turn = await agent.startTurn(prompt);
+        turn.subscribe({
+            next: (evt) => {
+                sseServer.emit(contextId, evt);
+            },
+            complete: async () => {
+                sseServer.shutdown();
+                state.busy = false;
+            },
+        });
+        const res = c.res;
+        logger.info({ contextId }, 'SSE connection established');
+        const stream = new ReadableStream({
+            start(controller) {
+                sseServer.subscribe({
+                    setHeader: (name, value) => {
+                        res.headers.set(name, value);
+                    },
+                    write: (chunk) => {
+                        controller.enqueue(new TextEncoder().encode(chunk));
+                    },
+                    end: function () {
+                        logger.info({ contextId }, 'SSE stream finished');
+                        this.writable = false;
+                        controller.close();
+                    },
+                }, {
+                    contextId,
+                }, undefined);
+            },
+            cancel: () => {
+                logger.info({ contextId }, 'Stream canceled');
+                sseServer.shutdown();
+                state.busy = false;
+            },
+        });
+        return new Response(stream, res);
+    });
+    serveNodeJs({
+        fetch: app.fetch,
+        port: config.port || 8080,
+    });
+};
+const getAuthContext = async (authorization, decoder) => {
+    if (!authorization || !decoder) {
+        return null;
+    }
+    return await decoder(authorization);
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './agentcore-runtime-server';
+export * from './stores';

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './agentcore-runtime-server';
+export * from './stores';

package/dist/stores/agentcore-memory-message-store.d.ts

@@ -0,0 +1,36 @@
+import { BedrockAgentCoreClient } from '@aws-sdk/client-bedrock-agentcore';
+import type { CompactionOptions, CompactionResult, Message, MessageStore } from '@looopy-ai/core';
+export interface AgentCoreMemoryMessageStoreConfig {
+    memoryId: string;
+    agentId: string;
+    region?: string;
+    client?: BedrockAgentCoreClient;
+    extractActorId?: (contextId: string) => string;
+    longTermMemoryNamespace?: string;
+}
+export declare class AgentCoreMemoryMessageStore implements MessageStore {
+    private readonly memoryId;
+    private readonly actorId;
+    private readonly includeLongTermMemories;
+    private readonly longTermMemoryNamespace?;
+    private readonly client;
+    constructor(config: AgentCoreMemoryMessageStoreConfig);
+    append(contextId: string, messages: Message[]): Promise<void>;
+    getRecent(contextId: string, options?: {
+        maxMessages?: number;
+        maxTokens?: number;
+    }): Promise<Message[]>;
+    getAll(contextId: string): Promise<Message[]>;
+    getCount(contextId: string): Promise<number>;
+    getRange(contextId: string, startIndex: number, endIndex: number): Promise<Message[]>;
+    compact(_contextId: string, _options?: CompactionOptions): Promise<CompactionResult>;
+    clear(contextId: string): Promise<void>;
+    searchMemories(query: string, options?: {
+        maxResults?: number;
+    }): Promise<unknown[]>;
+    private convertEventsToMessages;
+    private retrieveLongTermMemories;
+    private formatLongTermMemories;
+    private toAgentCoreRole;
+    private fromAgentCoreRole;
+}

package/dist/stores/agentcore-memory-message-store.js

@@ -0,0 +1,179 @@
+import { BedrockAgentCoreClient, CreateEventCommand, DeleteEventCommand, ListEventsCommand, RetrieveMemoryRecordsCommand, } from '@aws-sdk/client-bedrock-agentcore';
+import { trimToTokenBudget } from '@looopy-ai/core';
+export class AgentCoreMemoryMessageStore {
+    memoryId;
+    actorId;
+    includeLongTermMemories;
+    longTermMemoryNamespace;
+    client;
+    constructor(config) {
+        this.memoryId = config.memoryId;
+        this.actorId = config.agentId;
+        this.includeLongTermMemories = !!config.longTermMemoryNamespace;
+        this.longTermMemoryNamespace = config.longTermMemoryNamespace;
+        this.client =
+            config.client ||
+                new BedrockAgentCoreClient({
+                    region: config.region ?? process.env.AWS_REGION ?? 'us-west-2',
+                });
+    }
+    async append(contextId, messages) {
+        for (const message of messages) {
+            const command = new CreateEventCommand({
+                memoryId: this.memoryId,
+                actorId: this.actorId,
+                sessionId: contextId,
+                eventTimestamp: new Date(),
+                payload: [
+                    {
+                        conversational: {
+                            role: this.toAgentCoreRole(message.role),
+                            content: { text: message.content },
+                        },
+                    },
+                    {
+                        blob: {
+                            toolCallId: message.toolCallId,
+                            toolCalls: message.toolCalls,
+                        },
+                    },
+                ],
+            });
+            await this.client.send(command);
+        }
+    }
+    async getRecent(contextId, options) {
+        const command = new ListEventsCommand({
+            memoryId: this.memoryId,
+            actorId: this.actorId,
+            sessionId: contextId,
+            maxResults: options?.maxMessages ?? 50,
+        });
+        const response = await this.client.send(command);
+        const messages = this.convertEventsToMessages(response.events ?? []);
+        if (this.includeLongTermMemories && messages.length > 0) {
+            const longTerm = await this.retrieveLongTermMemories(this.actorId, 'relevant context');
+            if (longTerm.length > 0) {
+                messages.unshift({
+                    role: 'system',
+                    content: this.formatLongTermMemories(longTerm),
+                });
+            }
+        }
+        if (options?.maxTokens) {
+            return trimToTokenBudget(messages, options.maxTokens);
+        }
+        return messages;
+    }
+    async getAll(contextId) {
+        return this.getRecent(contextId, { maxMessages: 1000 });
+    }
+    async getCount(contextId) {
+        const messages = await this.getRecent(contextId);
+        return messages.length;
+    }
+    async getRange(contextId, startIndex, endIndex) {
+        const all = await this.getAll(contextId);
+        return all.slice(startIndex, endIndex);
+    }
+    async compact(_contextId, _options) {
+        return {
+            summaryMessages: [],
+            compactedRange: { start: 0, end: 0 },
+            tokensSaved: 0,
+        };
+    }
+    async clear(contextId) {
+        const list = await this.client.send(new ListEventsCommand({
+            memoryId: this.memoryId,
+            actorId: this.actorId,
+            sessionId: contextId,
+            maxResults: 1000,
+        }));
+        for (const event of list.events ?? []) {
+            if (!event.eventId)
+                continue;
+            await this.client.send(new DeleteEventCommand({
+                memoryId: this.memoryId,
+                actorId: this.actorId,
+                sessionId: contextId,
+                eventId: event.eventId,
+            }));
+        }
+    }
+    async searchMemories(query, options) {
+        return this.retrieveLongTermMemories(this.actorId, query, options?.maxResults ?? 10);
+    }
+    convertEventsToMessages(events) {
+        const messages = [];
+        events.sort((a, b) => {
+            const dateA = a.eventTimestamp?.getTime() ?? 0;
+            const dateB = b.eventTimestamp?.getTime() ?? 0;
+            return dateA - dateB;
+        });
+        for (const event of events) {
+            const message = { role: 'assistant', content: '' };
+            for (const payload of event.payload ?? []) {
+                if (payload.conversational) {
+                    message.role = this.fromAgentCoreRole(payload.conversational.role);
+                    message.content = payload.conversational.content?.text ?? '';
+                }
+                const blob = payload.blob;
+                if (blob?.toolCallId) {
+                    message.toolCallId = blob.toolCallId;
+                }
+                if (blob?.toolCalls) {
+                    message.toolCalls = blob.toolCalls;
+                }
+            }
+            messages.push(message);
+        }
+        return messages;
+    }
+    async retrieveLongTermMemories(_actorId, query, maxResults = 5) {
+        const command = new RetrieveMemoryRecordsCommand({
+            memoryId: this.memoryId,
+            namespace: this.longTermMemoryNamespace,
+            searchCriteria: {
+                searchQuery: query,
+                topK: maxResults,
+            },
+        });
+        const response = await this.client.send(command);
+        return response.memoryRecordSummaries ?? [];
+    }
+    formatLongTermMemories(memories) {
+        if (memories.length === 0) {
+            return '';
+        }
+        const lines = memories.map((record) => {
+            const data = record;
+            return `- ${String(data.content || data.memory || JSON.stringify(record))}`;
+        });
+        return `Relevant context from previous sessions:\n${lines.join('\n')}`;
+    }
+    toAgentCoreRole(role) {
+        switch (role) {
+            case 'user':
+                return 'USER';
+            case 'assistant':
+                return 'ASSISTANT';
+            case 'tool':
+                return 'TOOL';
+            default:
+                return 'OTHER';
+        }
+    }
+    fromAgentCoreRole(role) {
+        switch (role) {
+            case 'USER':
+                return 'user';
+            case 'ASSISTANT':
+                return 'assistant';
+            case 'TOOL':
+                return 'tool';
+            default:
+                return 'system';
+        }
+    }
+}

package/dist/stores/dynamodb-agent-store.d.ts

@@ -0,0 +1,33 @@
+import { type DynamoDBClientConfig } from '@aws-sdk/client-dynamodb';
+import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
+import type { AgentState, AgentStore } from '@looopy-ai/core';
+export interface DynamoDBAgentStoreConfig {
+    tableName: string;
+    agentId: string;
+    partitionKeyName?: string;
+    sortKeyName?: string;
+    agentKeyPrefix?: string;
+    contextKeyPrefix?: string;
+    consistentRead?: boolean;
+    entityType?: string;
+    documentClient?: DynamoDBDocumentClient;
+    dynamoDbClientConfig?: DynamoDBClientConfig;
+}
+export declare class DynamoDBAgentStore implements AgentStore {
+    private readonly tableName;
+    private readonly agentId;
+    private readonly partitionKeyName;
+    private readonly sortKeyName;
+    private readonly agentKeyPrefix;
+    private readonly contextKeyPrefix;
+    private readonly consistentRead;
+    private readonly entityType;
+    private readonly documentClient;
+    constructor(config: DynamoDBAgentStoreConfig);
+    load(contextId: string): Promise<AgentState | null>;
+    save(contextId: string, state: AgentState): Promise<void>;
+    delete(contextId: string): Promise<void>;
+    private buildKey;
+    private serializeState;
+    private deserializeState;
+}

package/dist/stores/dynamodb-agent-store.js

@@ -0,0 +1,88 @@
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { DeleteCommand, DynamoDBDocumentClient, GetCommand, PutCommand, } from '@aws-sdk/lib-dynamodb';
+export class DynamoDBAgentStore {
+    tableName;
+    agentId;
+    partitionKeyName;
+    sortKeyName;
+    agentKeyPrefix;
+    contextKeyPrefix;
+    consistentRead;
+    entityType;
+    documentClient;
+    constructor(config) {
+        if (!config.tableName) {
+            throw new Error('DynamoDBAgentStore requires a tableName');
+        }
+        if (!config.agentId) {
+            throw new Error('DynamoDBAgentStore requires an agentId');
+        }
+        this.tableName = config.tableName;
+        this.agentId = config.agentId;
+        this.partitionKeyName = config.partitionKeyName || 'pk';
+        this.sortKeyName = config.sortKeyName || 'sk';
+        this.agentKeyPrefix = config.agentKeyPrefix || 'agent#';
+        this.contextKeyPrefix = config.contextKeyPrefix || 'context#';
+        this.consistentRead = config.consistentRead ?? true;
+        this.entityType = config.entityType || 'agent-state';
+        this.documentClient =
+            config.documentClient ||
+                DynamoDBDocumentClient.from(new DynamoDBClient(config.dynamoDbClientConfig ?? {}));
+    }
+    async load(contextId) {
+        const command = new GetCommand({
+            TableName: this.tableName,
+            Key: this.buildKey(contextId),
+            ConsistentRead: this.consistentRead,
+        });
+        const response = await this.documentClient.send(command);
+        if (!response.Item) {
+            return null;
+        }
+        const item = response.Item;
+        if (!item.state) {
+            return null;
+        }
+        return this.deserializeState(item.state);
+    }
+    async save(contextId, state) {
+        const serializable = this.serializeState(state);
+        const command = new PutCommand({
+            TableName: this.tableName,
+            Item: {
+                ...this.buildKey(contextId),
+                entityType: this.entityType,
+                state: serializable,
+                updatedAt: new Date().toISOString(),
+            },
+        });
+        await this.documentClient.send(command);
+    }
+    async delete(contextId) {
+        const command = new DeleteCommand({
+            TableName: this.tableName,
+            Key: this.buildKey(contextId),
+        });
+        await this.documentClient.send(command);
+    }
+    buildKey(contextId) {
+        return {
+            [this.partitionKeyName]: `${this.agentKeyPrefix}${this.agentId}`,
+            [this.sortKeyName]: `${this.contextKeyPrefix}${contextId}`,
+        };
+    }
+    serializeState(state) {
+        return {
+            ...state,
+            createdAt: state.createdAt.toISOString(),
+            lastActivity: state.lastActivity.toISOString(),
+        };
+    }
+    deserializeState(state) {
+        return {
+            ...state,
+            createdAt: new Date(state.createdAt),
+            lastActivity: new Date(state.lastActivity),
+        };
+    }
+}

package/dist/stores/index.d.ts

@@ -0,0 +1,2 @@
+export * from './agentcore-memory-message-store';
+export * from './dynamodb-agent-store';

package/dist/stores/index.js

@@ -0,0 +1,2 @@
+export * from './agentcore-memory-message-store';
+export * from './dynamodb-agent-store';

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@looopy-ai/aws",
+  "version": "1.0.1",
+  "description": "AWS storage and providers for Looopy AI",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./package.json": "./package.json",
+    "./ts": "./src/index.ts",
+    "./ts/events": "./src/events/index.ts",
+    "./ts/observability": "./src/observability/index.ts",
+    "./ts/providers": "./src/providers/index.ts",
+    "./ts/stores": "./src/stores/index.ts",
+    "./ts/server": "./src/server/index.ts",
+    "./ts/tools": "./src/tools/index.ts"
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "keywords": [
+    "agent",
+    "ai",
+    "rxjs",
+    "a2a",
+    "llm",
+    "aws",
+    "bedrock",
+    "agentcore"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@aws-sdk/client-bedrock-agentcore": "^3.932.0",
+    "@aws-sdk/client-dynamodb": "^3.932.0",
+    "@aws-sdk/lib-dynamodb": "^3.932.0",
+    "@hono/node-server": "^1.19.6",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.207.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.207.0",
+    "@opentelemetry/instrumentation": "^0.207.0",
+    "@opentelemetry/resources": "^2.2.0",
+    "@opentelemetry/sdk-metrics": "^2.2.0",
+    "@opentelemetry/sdk-trace-base": "^2.2.0",
+    "@opentelemetry/sdk-trace-node": "^2.2.0",
+    "@opentelemetry/semantic-conventions": "^1.37.0",
+    "@smithy/types": "^4.9.0",
+    "hono": "^4.10.5",
+    "pino-http": "^11.0.0",
+    "@looopy-ai/core": "1.0.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "check:exports": "pnpx ts-unused-exports ./tsconfig.json --excludePathsFromReport='index'",
+    "check:types": "tsc --noEmit",
+    "test": "CI=true vitest",
+    "test:watch": "vitest --watch",
+    "test:coverage": "vitest --coverage",
+    "agentcore": "tsx src/agentcore-runtime-server.ts",
+    "build": "tsc -p tsconfig.esm.json",
+    "lint": "biome check src",
+    "lint:fix": "biome check --write src"
+  }
+}