@looopy-ai/aws 2.1.13 → 2.1.15

package/dist/agentcore-runtime-server.js

@@ -1,10 +1,7 @@
-import { getLogger, SSEServer } from '@looopy-ai/core';
+import { getLogger } from '@looopy-ai/core';
 import { Hono as BaseHono } from 'hono';
 import { requestId } from 'hono/request-id';
-import { z } from 'zod';
-const promptValidator = z.looseObject({
-    prompt: z.string().min(1),
-});
+import { handlePrompt } from './invocations/prompt';
 export const hono = (config) => {
     const app = new BaseHono();
     app.use(requestId());
@@ -77,50 +74,20 @@ export const hono = (config) => {
         return processRequest(c, async (agent, authContext, logger) => {
             state.busy = true;
             const body = await c.req.json();
-            const promptValidation = promptValidator.safeParse(body);
-            if (!promptValidation.success) {
+            if (!body || typeof body !== 'object') {
                 state.busy = false;
-                return c.json({ error: 'Invalid prompt', details: promptValidation.error.issues }, 400);
+                return c.json({ error: 'Invalid request body' }, 400);
+            }
+            switch (body.type) {
+                case 'prompt':
+                    return handlePrompt(agent, body, authContext, c.res, logger, () => {
+                        state.busy = false;
+                    }, () => {
+                        state.busy = false;
+                    });
+                default:
+                    return c.json({ error: 'Unsupported invocation type' }, 400);
             }
-            const { prompt, ...metadata } = promptValidation.data;
-            const sseServer = new SSEServer();
-            const turn = await agent.startTurn(prompt, { authContext, metadata });
-            turn.subscribe({
-                next: (evt) => {
-                    sseServer.emit(agent.contextId, evt);
-                },
-                complete: async () => {
-                    sseServer.shutdown();
-                    state.busy = false;
-                },
-            });
-            const res = c.res;
-            logger.info('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('SSE stream finished');
-                            this.writable = false;
-                            controller.close();
-                        },
-                    }, {
-                        contextId: agent.contextId,
-                    }, undefined);
-                },
-                cancel: () => {
-                    logger.info('Stream canceled');
-                    sseServer.shutdown();
-                    state.busy = false;
-                },
-            });
-            return new Response(stream, res);
         });
     });
     return app;

package/dist/invocations/prompt.d.ts

@@ -0,0 +1,3 @@
+import { type Agent } from '@looopy-ai/core';
+import type pino from 'pino';
+export declare const handlePrompt: <AuthContext>(agent: Agent<AuthContext>, body: unknown, authContext: AuthContext | undefined, res: Response, logger: pino.Logger, onComplete: () => void, onError: () => void) => Promise<Response>;

package/dist/invocations/prompt.js

@@ -0,0 +1,48 @@
+import { SSEServer } from '@looopy-ai/core';
+import { z } from 'zod';
+const promptValidator = z.looseObject({
+    prompt: z.string().min(1),
+});
+export const handlePrompt = async (agent, body, authContext, res, logger, onComplete, onError) => {
+    const promptValidation = promptValidator.safeParse(body);
+    if (!promptValidation.success) {
+        onError();
+        return Response.json({ error: 'Invalid prompt', details: promptValidation.error.issues }, { status: 400 });
+    }
+    const { prompt, ...metadata } = promptValidation.data;
+    const sseServer = new SSEServer();
+    const turn = await agent.startTurn(prompt, { authContext, metadata });
+    turn.subscribe({
+        next: (evt) => {
+            sseServer.emit(agent.contextId, evt);
+        },
+        complete: async () => {
+            sseServer.shutdown();
+            onComplete();
+        },
+    });
+    logger.info('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('SSE stream finished');
+                    this.writable = false;
+                    controller.close();
+                },
+            }, { contextId: agent.contextId }, undefined);
+        },
+        cancel: () => {
+            logger.info('Stream canceled');
+            sseServer.shutdown();
+            onComplete();
+        },
+    });
+    return new Response(stream, res);
+};

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

@@ -12,6 +12,7 @@ export interface DynamoDBAgentStoreConfig {
     entityType?: string;
     documentClient?: DynamoDBDocumentClient;
     dynamoDbClientConfig?: DynamoDBClientConfig;
+    ttlSeconds?: number;
 }
 export declare class DynamoDBAgentStore implements AgentStore {
     private readonly tableName;
@@ -23,6 +24,7 @@ export declare class DynamoDBAgentStore implements AgentStore {
     private readonly consistentRead;
     private readonly entityType;
     private readonly documentClient;
+    private readonly ttlSeconds;
     constructor(config: DynamoDBAgentStoreConfig);
     load(contextId: string): Promise<AgentState | null>;
     save(contextId: string, state: AgentState): Promise<void>;

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

@@ -10,6 +10,7 @@ export class DynamoDBAgentStore {
     consistentRead;
     entityType;
     documentClient;
+    ttlSeconds;
     constructor(config) {
         if (!config.tableName) {
             throw new Error('DynamoDBAgentStore requires a tableName');
@@ -46,6 +47,7 @@ export class DynamoDBAgentStore {
         return this.deserializeState(item.state);
     }
     async save(contextId, state) {
+        const now = Math.floor(Date.now() / 1000);
         const serializable = this.serializeState(state);
         const command = new PutCommand({
             TableName: this.tableName,
@@ -53,7 +55,8 @@ export class DynamoDBAgentStore {
                 ...this.buildKey(contextId),
                 entityType: this.entityType,
                 state: serializable,
-                updatedAt: new Date().toISOString(),
+                updatedAt: now,
+                expires: this.ttlSeconds ? now + this.ttlSeconds : null,
             },
         });
         await this.documentClient.send(command);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@looopy-ai/aws",
-  "version": "2.1.13",
+  "version": "2.1.15",
   "description": "AWS storage and providers for Looopy AI",
   "repository": {
     "url": "https://github.com/looopy-ai/lib"
@@ -55,7 +55,7 @@
     "@smithy/types": "^4.9.0",
     "hono": "^4.10.5",
     "pino-http": "^11.0.0",
-    "@looopy-ai/core": "2.1.12"
+    "@looopy-ai/core": "2.1.14"
   },
   "publishConfig": {
     "access": "public"