quidproquo-actionprocessor-awslambda 0.0.261 → 0.0.263

package/lib/commonjs/getActionProcessor/core/userDirectory/getUserDirectoryCreateUserActionProcessor.js

@@ -15,12 +15,17 @@ const quidproquo_core_1 = require("quidproquo-core");
 const awsNamingUtils_1 = require("../../../awsNamingUtils");
 const getExportedValue_1 = require("../../../logic/cloudformation/getExportedValue");
 const createUser_1 = require("../../../logic/cognito/createUser");
+const resolveUsernameByPreferredUsername_1 = require("../../../logic/cognito/resolveUsernameByPreferredUsername");
 const getProcessCreateUser = (qpqConfig) => {
     return (payload) => __awaiter(void 0, void 0, void 0, function* () {
         const region = quidproquo_config_aws_1.qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
         const userPoolId = yield (0, getExportedValue_1.getExportedValue)((0, awsNamingUtils_1.getCFExportNameUserPoolIdFromConfig)(payload.userDirectoryName, qpqConfig), region);
         const userPoolClientId = yield (0, getExportedValue_1.getExportedValue)((0, awsNamingUtils_1.getCFExportNameUserPoolClientIdFromConfig)(payload.userDirectoryName, qpqConfig), region);
-        const authResponse = yield (0, createUser_1.createUser)(userPoolId, quidproquo_config_aws_1.qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig), userPoolClientId, payload.createUserRequest);
+        const resolvedUsername = yield (0, resolveUsernameByPreferredUsername_1.resolveUsernameByPreferredUsername)(userPoolId, region, payload.createUserRequest.email);
+        if (resolvedUsername !== payload.createUserRequest.email) {
+            return (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.ErrorTypeEnum.Conflict, 'An account with this email already exists');
+        }
+        const authResponse = yield (0, createUser_1.createUser)(userPoolId, region, userPoolClientId, payload.createUserRequest);
         return (0, quidproquo_core_1.actionResult)(authResponse);
     });
 };

package/lib/commonjs/getActionProcessor/webserver/serviceFunction/getServiceFunctionExecuteActionProcessor.js

@@ -16,7 +16,7 @@ const quidproquo_webserver_1 = require("quidproquo-webserver");
 const awsNamingUtils_1 = require("../../../awsNamingUtils");
 const executeLambdaByName_1 = require("../../../logic/lambda/executeLambdaByName");
 const getProcessExecute = (qpqConfig) => {
-    return (_a, session_1) => __awaiter(void 0, [_a, session_1], void 0, function* ({ functionName, service, payload, context, isAsync }, session) {
+    return (_a, session_1) => __awaiter(void 0, [_a, session_1], void 0, function* ({ functionName, service, payload, isAsync }, session) {
         const region = quidproquo_config_aws_1.qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
         const appName = quidproquo_core_1.qpqCoreUtils.getApplicationName(qpqConfig);
         const environment = quidproquo_core_1.qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig);
@@ -25,7 +25,7 @@ const getProcessExecute = (qpqConfig) => {
         const serviceFunctionEvent = {
             functionName: functionName,
             payload: payload,
-            storySession: Object.assign(Object.assign({}, session), { context }),
+            storySession: session,
         };
         const result = yield (0, executeLambdaByName_1.executeLambdaByName)(awsFunctionName, region, serviceFunctionEvent, isAsync);
         if (!result) {

package/lib/esm/getActionProcessor/core/ai/aiModelMap.d.ts

@@ -0,0 +1,2 @@
+import { AiModel } from 'quidproquo-core';
+export declare const bedrockModelMap: Record<AiModel, string>;

package/lib/esm/getActionProcessor/core/ai/aiModelMap.js

@@ -0,0 +1,12 @@
+import { AiModel } from 'quidproquo-core';
+export const bedrockModelMap = {
+    [AiModel.ClaudeHaiku35]: 'us.anthropic.claude-3-5-haiku-20241022-v1:0',
+    [AiModel.ClaudeSonnet35]: 'us.anthropic.claude-3-5-sonnet-20241022-v2:0',
+    [AiModel.ClaudeSonnet4]: 'us.anthropic.claude-sonnet-4-20250514-v1:0',
+    [AiModel.ClaudeOpus4]: 'us.anthropic.claude-opus-4-20250514-v1:0',
+    [AiModel.ClaudeHaiku45]: 'us.anthropic.claude-haiku-4-5-20251001-v1:0',
+    [AiModel.ClaudeSonnet45]: 'us.anthropic.claude-sonnet-4-5-20250929-v1:0',
+    [AiModel.ClaudeOpus45]: 'us.anthropic.claude-opus-4-5-20251101-v1:0',
+    [AiModel.ClaudeSonnet46]: 'us.anthropic.claude-sonnet-4-6',
+    [AiModel.ClaudeOpus46]: 'us.anthropic.claude-opus-4-6-v1',
+};

package/lib/esm/getActionProcessor/core/ai/getAiPromptActionProcessor.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getAiPromptActionProcessor: ActionProcessorListResolver;

package/lib/esm/getActionProcessor/core/ai/getAiPromptActionProcessor.js

@@ -0,0 +1,60 @@
+import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
+import { actionResult, actionResultError, AiActionType, askInlineFunctionExecute, createImplementationRuntime, ErrorTypeEnum, qpqCoreUtils, } from 'quidproquo-core';
+import { generateText, jsonSchema, stepCountIs } from 'ai';
+import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
+import { randomGuid } from '../../../awsLambdaUtils';
+import { bedrockModelMap } from './aiModelMap';
+const getProcessAiPrompt = (qpqConfig) => {
+    return async (payload, session, actionProcessorList, logger, updateSession, dynamicModuleLoader, streamRegistry) => {
+        const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
+        const bedrock = createAmazonBedrock({ region });
+        const bedrockModelId = bedrockModelMap[payload.model];
+        if (!bedrockModelId) {
+            return actionResultError(ErrorTypeEnum.NotImplemented, `Unsupported AI model: ${payload.model}`);
+        }
+        // Build tools from defineAi config if aiName is provided
+        const aiTools = {};
+        if (payload.aiName) {
+            const aiConfigs = qpqCoreUtils.getAllAiConfigs(qpqConfig);
+            const aiConfig = aiConfigs.find((c) => c.aiName === payload.aiName);
+            if (!aiConfig) {
+                return actionResultError(ErrorTypeEnum.NotFound, `AI config not found: ${payload.aiName}`);
+            }
+            for (const toolDef of aiConfig.tools) {
+                aiTools[toolDef.name] = {
+                    description: toolDef.description,
+                    inputSchema: jsonSchema(toolDef.inputSchema),
+                    execute: async (args) => {
+                        const resolveStory = createImplementationRuntime(qpqConfig, [`AI Tool: ${toolDef.name}`], () => new Date().toISOString(), randomGuid, session, actionProcessorList, logger, dynamicModuleLoader, streamRegistry);
+                        const storyResult = await resolveStory(function* () {
+                            return yield* askInlineFunctionExecute(toolDef.executor, args);
+                        }, []);
+                        if (storyResult.error) {
+                            throw new Error(storyResult.error.errorText);
+                        }
+                        return storyResult.result;
+                    },
+                };
+            }
+        }
+        try {
+            const result = await generateText({
+                model: bedrock(bedrockModelId),
+                system: payload.system,
+                prompt: payload.prompt,
+                tools: Object.keys(aiTools).length > 0 ? aiTools : undefined,
+                stopWhen: stepCountIs(10),
+            });
+            return actionResult({ text: result.text });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                return actionResultError(ErrorTypeEnum.GenericError, error.message);
+            }
+            return actionResultError(ErrorTypeEnum.GenericError, 'An error occurred during AI prompt execution.');
+        }
+    };
+};
+export const getAiPromptActionProcessor = async (qpqConfig) => ({
+    [AiActionType.Prompt]: getProcessAiPrompt(qpqConfig),
+});

package/lib/esm/getActionProcessor/core/ai/getAiPromptStreamActionProcessor.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getAiPromptStreamActionProcessor: ActionProcessorListResolver;

package/lib/esm/getActionProcessor/core/ai/getAiPromptStreamActionProcessor.js

@@ -0,0 +1,75 @@
+import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
+import { actionResult, actionResultError, AiActionType, askInlineFunctionExecute, createImplementationRuntime, ErrorTypeEnum, qpqCoreUtils, } from 'quidproquo-core';
+import { jsonSchema, stepCountIs, streamText } from 'ai';
+import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
+import { randomGuid } from '../../../awsLambdaUtils';
+import { bedrockModelMap } from './aiModelMap';
+const getProcessAiPromptStream = (qpqConfig) => {
+    return async (payload, session, actionProcessorList, logger, updateSession, dynamicModuleLoader, streamRegistry) => {
+        const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
+        const bedrock = createAmazonBedrock({ region });
+        const bedrockModelId = bedrockModelMap[payload.model];
+        if (!bedrockModelId) {
+            return actionResultError(ErrorTypeEnum.NotImplemented, `Unsupported AI model: ${payload.model}`);
+        }
+        // Build tools from defineAi config if aiName is provided
+        const aiTools = {};
+        if (payload.aiName) {
+            const aiConfigs = qpqCoreUtils.getAllAiConfigs(qpqConfig);
+            const aiConfig = aiConfigs.find((c) => c.aiName === payload.aiName);
+            if (!aiConfig) {
+                return actionResultError(ErrorTypeEnum.NotFound, `AI config not found: ${payload.aiName}`);
+            }
+            for (const toolDef of aiConfig.tools) {
+                aiTools[toolDef.name] = {
+                    description: toolDef.description,
+                    inputSchema: jsonSchema(toolDef.inputSchema),
+                    execute: async (args) => {
+                        const resolveStory = createImplementationRuntime(qpqConfig, [`AI Tool: ${toolDef.name}`], () => new Date().toISOString(), randomGuid, session, actionProcessorList, logger, dynamicModuleLoader, streamRegistry);
+                        const storyResult = await resolveStory(function* () {
+                            return yield* askInlineFunctionExecute(toolDef.executor, args);
+                        }, []);
+                        if (storyResult.error) {
+                            throw new Error(storyResult.error.errorText);
+                        }
+                        return storyResult.result;
+                    },
+                };
+            }
+        }
+        try {
+            const { fullStream } = streamText({
+                model: bedrock(bedrockModelId),
+                system: payload.system,
+                prompt: payload.messages ?? payload.prompt,
+                tools: Object.keys(aiTools).length > 0 ? aiTools : undefined,
+                stopWhen: stepCountIs(10),
+            });
+            const streamId = `ai-prompt-${Date.now()}-${randomGuid()}`;
+            async function* aiStreamIterator() {
+                for await (const part of fullStream) {
+                    if (part.type === 'text-delta') {
+                        yield JSON.stringify({ type: 'text-delta', text: part.text });
+                    }
+                    else if (part.type === 'tool-call') {
+                        yield JSON.stringify({ type: 'tool-call', toolName: part.toolName, input: part.input });
+                    }
+                    else if (part.type === 'tool-result') {
+                        yield JSON.stringify({ type: 'tool-result', toolName: part.toolName, output: part.output });
+                    }
+                }
+            }
+            streamRegistry.register(streamId, aiStreamIterator());
+            return actionResult({ id: streamId, encoding: 'json' });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                return actionResultError(ErrorTypeEnum.GenericError, error.message);
+            }
+            return actionResultError(ErrorTypeEnum.GenericError, 'An error occurred during AI prompt stream.');
+        }
+    };
+};
+export const getAiPromptStreamActionProcessor = async (qpqConfig) => ({
+    [AiActionType.PromptStream]: getProcessAiPromptStream(qpqConfig),
+});

package/lib/esm/getActionProcessor/core/ai/index.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getAiActionProcessor: ActionProcessorListResolver;

package/lib/esm/getActionProcessor/core/ai/index.js

@@ -0,0 +1,6 @@
+import { getAiPromptActionProcessor } from './getAiPromptActionProcessor';
+import { getAiPromptStreamActionProcessor } from './getAiPromptStreamActionProcessor';
+export const getAiActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getAiPromptActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getAiPromptStreamActionProcessor(qpqConfig, dynamicModuleLoader)),
+});

package/lib/esm/getActionProcessor/core/apiKeyValidation/getApiKeyValidationValidateActionProcessor.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getApiKeyValidationValidateActionProcessor: ActionProcessorListResolver;

package/lib/esm/getActionProcessor/core/apiKeyValidation/getApiKeyValidationValidateActionProcessor.js

@@ -0,0 +1,24 @@
+import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
+import { actionResult, qpqCoreUtils, } from 'quidproquo-core';
+import { ApiKeyValidationActionType } from 'quidproquo-webserver';
+import { getConfigRuntimeResourceName } from '../../../awsNamingUtils';
+import { getApiKeys } from '../../../logic/apiGateway/getApiKeys';
+const getProcessApiKeyValidationValidate = (qpqConfig) => {
+    const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
+    const application = qpqCoreUtils.getApplicationName(qpqConfig);
+    const service = qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    const environment = qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig);
+    const feature = qpqCoreUtils.getApplicationModuleFeature(qpqConfig);
+    return async ({ apiKeyValue, apiKeyReferences }) => {
+        const realApiKeys = await getApiKeys(region, ...apiKeyReferences.map((apiKey) => {
+            const apiKeyApplication = apiKey.applicationName || application;
+            const apiKeyService = apiKey.serviceName || service;
+            return getConfigRuntimeResourceName(apiKey.name, apiKeyApplication, apiKeyService, environment, feature);
+        }));
+        const index = realApiKeys.findIndex((apiKey) => apiKey.value === apiKeyValue);
+        return actionResult(index >= 0);
+    };
+};
+export const getApiKeyValidationValidateActionProcessor = async (qpqConfig) => ({
+    [ApiKeyValidationActionType.Validate]: getProcessApiKeyValidationValidate(qpqConfig),
+});

package/lib/esm/getActionProcessor/core/apiKeyValidation/index.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getApiKeyValidationActionProcessor: ActionProcessorListResolver;

package/lib/esm/getActionProcessor/core/apiKeyValidation/index.js

@@ -0,0 +1,4 @@
+import { getApiKeyValidationValidateActionProcessor } from './getApiKeyValidationValidateActionProcessor';
+export const getApiKeyValidationActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getApiKeyValidationValidateActionProcessor(qpqConfig, dynamicModuleLoader)),
+});

package/lib/esm/getActionProcessor/core/event/apiGatwayEvent/api/getEventAutoRespondActionProcessor.js

@@ -1,33 +1,4 @@
-import { actionResult, EventActionType, } from 'quidproquo-core';
-import { qpqWebServerUtils } from 'quidproquo-webserver';
-import { isAuthValid } from '../../utils/isAuthValid';
-const getProcessAutoRespond = (qpqConfig) => {
-    return async ({ qpqEventRecord, matchResult }) => {
-        // Just auto respond for options requests
-        if (qpqEventRecord.method === 'OPTIONS') {
-            return actionResult({
-                status: 200,
-                isBase64Encoded: false,
-                body: '',
-                headers: qpqWebServerUtils.getCorsHeaders(qpqConfig, matchResult.config || {}, qpqEventRecord.headers),
-            });
-        }
-        // TODO: We can pull out the jwt from the session if thats a better way?
-        // Think about that when you dont have covid.
-        const authValid = await isAuthValid(qpqConfig, qpqWebServerUtils.getHeaderValue('Authorization', qpqEventRecord.headers), qpqWebServerUtils.getHeaderValue('x-api-key', qpqEventRecord.headers), matchResult.config?.routeAuthSettings);
-        if (!authValid) {
-            return actionResult({
-                status: 401,
-                isBase64Encoded: false,
-                body: JSON.stringify({
-                    message: 'You are unauthorized to access this resource',
-                }),
-                headers: qpqWebServerUtils.getCorsHeaders(qpqConfig, matchResult.config || {}, qpqEventRecord.headers),
-            });
-        }
-        return actionResult(null);
-    };
-};
-export const getEventAutoRespondActionProcessor = async (qpqConfig) => ({
-    [EventActionType.AutoRespond]: getProcessAutoRespond(qpqConfig),
+import { getHttpApiEventAutoRespondActionProcessor } from 'quidproquo-webserver';
+export const getEventAutoRespondActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getHttpApiEventAutoRespondActionProcessor(qpqConfig, dynamicModuleLoader)),
 });

package/lib/esm/getActionProcessor/core/event/apiGatwayEvent/api/getEventGetStorySessionActionProcessor.js

@@ -1,36 +1,4 @@
-import { actionResult, EventActionType, } from 'quidproquo-core';
-import { qpqWebServerUtils } from 'quidproquo-webserver';
-import { decodeAccessToken } from '../../../../../logic/cognito';
-const getProcessGetStorySession = (qpqConfig) => {
-    return async ({ matchStoryResult, qpqEventRecord }, session) => {
-        const accessToken = qpqWebServerUtils.getAccessTokenFromHeaders(qpqEventRecord.headers);
-        if (!accessToken) {
-            return actionResult(void 0);
-        }
-        // if this endpoint has no auth settings, BUT we do have an access token
-        // then we want to just attempt to extract info for logs, but we will say that its
-        // wasValid = false
-        if (!matchStoryResult.config?.routeAuthSettings?.userDirectoryName) {
-            // If this endpoint is unauthenticated, then we will just decode it, and say it wasnt valid, for logs
-            const info = qpqWebServerUtils.decodeJWT(accessToken);
-            return actionResult({
-                ...session,
-                decodedAccessToken: {
-                    exp: info?.exp || 0,
-                    userDirectory: '',
-                    userId: info?.sub || info?.id || info?.userId || info?.username || '',
-                    username: info?.username || info?.userId || info?.sub || info?.id || '',
-                    wasValid: false,
-                },
-            });
-        }
-        const decodedAccessToken = await decodeAccessToken(matchStoryResult.config.routeAuthSettings.userDirectoryName, qpqConfig, accessToken, true);
-        return actionResult({
-            ...session,
-            decodedAccessToken,
-        });
-    };
-};
-export const getEventGetStorySessionActionProcessor = async (qpqConfig) => ({
-    [EventActionType.GetStorySession]: getProcessGetStorySession(qpqConfig),
+import { getHttpApiEventGetStorySessionActionProcessor } from 'quidproquo-webserver';
+export const getEventGetStorySessionActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getHttpApiEventGetStorySessionActionProcessor(qpqConfig, dynamicModuleLoader)),
 });

package/lib/esm/getActionProcessor/core/event/apiGatwayEvent/websocket/getEventTransformResponseResultActionProcessor.js

@@ -11,10 +11,10 @@ export function* askTransformResponseStory({ eventParams, qpqEventRecordResponse
 const getProcessTransformResponseResult = (qpqConfig) => {
     // Create a custom runtime for errored responses so we can log them out
     const errorCustomImplementation = getProcessCustomImplementation(qpqConfig, askTransformResponseStory, 'Transform Errored Websocket Response', null, () => new Date().toISOString(), randomGuid);
-    return async (payload, session, actionProcessors, logger, updateSession, dynamicModuleLoader) => {
+    return async (payload, session, actionProcessors, logger, updateSession, dynamicModuleLoader, streamRegistry) => {
         if (payload.qpqEventRecordResponses.some((r) => !r.success)) {
             // We only wan't to run this for errors, because a custom imp is slower then a regular imp
-            return await errorCustomImplementation(payload, session, actionProcessors, logger, updateSession, dynamicModuleLoader);
+            return await errorCustomImplementation(payload, session, actionProcessors, logger, updateSession, dynamicModuleLoader, streamRegistry);
         }
         return actionResult({
             statusCode: 200,

package/lib/esm/getActionProcessor/core/eventBus/getEventBusSendMessagesActionProcessor.js

@@ -3,7 +3,7 @@ import { actionResult, actionResultError, ErrorTypeEnum, EventBusActionType, qpq
 import { getEventBusSnsTopicArn } from '../../../awsNamingUtils';
 import { publishMessage } from '../../../logic/sns/publishMessage';
 const getProcessEventBusSendMessage = (qpqConfig) => {
-    return async ({ eventBusName, eventBusMessages, context, }, session) => {
+    return async ({ eventBusName, eventBusMessages, }, session) => {
         const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
         const eventBusConfig = qpqCoreUtils.getEventBusConfigByName(eventBusName, qpqConfig);
         if (!eventBusConfig) {
@@ -13,10 +13,7 @@ const getProcessEventBusSendMessage = (qpqConfig) => {
         await publishMessage(topicArn, region, eventBusMessages.map((message) => {
             const eventBusMessageWithSession = {
                 ...message,
-                storySession: {
-                    ...session,
-                    context,
-                },
+                storySession: session,
             };
             return JSON.stringify(eventBusMessageWithSession);
         }));

package/lib/esm/getActionProcessor/core/file/getFileStreamOpenActionProcessor.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getFileStreamOpenActionProcessor: ActionProcessorListResolver;

package/lib/esm/getActionProcessor/core/file/getFileStreamOpenActionProcessor.js

@@ -0,0 +1,50 @@
+import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, ErrorTypeEnum, FileActionType, } from 'quidproquo-core';
+import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import { createAwsClient } from '../../../logic/createAwsClient';
+import { resolveStorageDriveBucketName } from './utils';
+async function* chunkedReadableIterator(stream, chunkSize, transform) {
+    let buffer = Buffer.alloc(0);
+    for await (const chunk of stream) {
+        const incoming = typeof chunk === 'string' ? Buffer.from(chunk, 'utf8') : chunk;
+        buffer = Buffer.concat([buffer, incoming]);
+        while (buffer.length >= chunkSize) {
+            yield transform(buffer.subarray(0, chunkSize));
+            buffer = buffer.subarray(chunkSize);
+        }
+    }
+    if (buffer.length > 0) {
+        yield transform(buffer);
+    }
+}
+const getProcessFileStreamOpen = (qpqConfig) => {
+    return async ({ drive, filepath, encoding, chunkSize }, session, actionProcessors, logger, updateSession, dynamicModuleLoader, streamRegistry) => {
+        try {
+            const s3BucketName = resolveStorageDriveBucketName(drive, qpqConfig);
+            const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
+            const s3Client = createAwsClient(S3Client, { region });
+            const response = await s3Client.send(new GetObjectCommand({
+                Key: filepath,
+                Bucket: s3BucketName,
+            }));
+            if (!response.Body) {
+                return actionResultError(ErrorTypeEnum.GenericError, `Empty response body for: ${filepath}`);
+            }
+            const streamId = `s3-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+            const isText = encoding === 'text';
+            const size = chunkSize ?? 65536;
+            const transform = isText
+                ? (buf) => buf.toString('utf8')
+                : (buf) => buf.toString('base64');
+            const iterator = chunkedReadableIterator(response.Body, size, transform);
+            streamRegistry.register(streamId, iterator);
+            return actionResult({ id: streamId, encoding });
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {});
+        }
+    };
+};
+export const getFileStreamOpenActionProcessor = async (qpqConfig) => ({
+    [FileActionType.StreamOpen]: getProcessFileStreamOpen(qpqConfig),
+});

package/lib/esm/getActionProcessor/core/file/index.js

@@ -7,6 +7,7 @@ import { getFileListDirectoryActionProcessor } from './getFileListDirectoryActio
 import { getFileReadBinaryContentsActionProcessor } from './getFileReadBinaryContentsActionProcessor';
 import { getFileReadObjectJsonActionProcessor } from './getFileReadObjectJsonActionProcessor';
 import { getFileReadTextContentsActionProcessor } from './getFileReadTextContentsActionProcessor';
+import { getFileStreamOpenActionProcessor } from './getFileStreamOpenActionProcessor';
 import { getFileWriteBinaryContentsActionProcessor } from './getFileWriteBinaryContentsActionProcessor';
 import { getFileWriteObjectJsonActionProcessor } from './getFileWriteObjectJsonActionProcessor';
 import { getFileWriteTextContentsActionProcessor } from './getFileWriteTextContentsActionProcessor';
@@ -23,4 +24,5 @@ export const getFileActionProcessor = async (qpqConfig, dynamicModuleLoader) =>
     ...(await getFileReadBinaryContentsActionProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getFileWriteObjectJsonActionProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getFileWriteBinaryContentsActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getFileStreamOpenActionProcessor(qpqConfig, dynamicModuleLoader)),
 });

package/lib/esm/getActionProcessor/core/index.d.ts

@@ -1,3 +1,5 @@
+export * from './ai';
+export * from './apiKeyValidation';
 export * from './config';
 export * from './event';
 export * from './eventBus';

package/lib/esm/getActionProcessor/core/index.js

@@ -1,3 +1,5 @@
+export * from './ai';
+export * from './apiKeyValidation';
 export * from './config';
 export * from './event';
 export * from './eventBus';
@@ -7,6 +9,9 @@ export * from './keyValueStore';
 export * from './queue';
 export * from './system';
 export * from './userDirectory';
+import { getRouteAuthValidationActionProcessor } from 'quidproquo-webserver';
+import { getAiActionProcessor } from './ai';
+import { getApiKeyValidationActionProcessor } from './apiKeyValidation';
 import { getConfigActionProcessor } from './config';
 import { getApiGatewayApiEventEventProcessor } from './event';
 import { getEventBusActionProcessor } from './eventBus';
@@ -17,6 +22,8 @@ import { getQueueActionProcessor } from './queue';
 import { getSystemActionProcessor } from './system';
 import { getUserDirectoryActionProcessor } from './userDirectory';
 export const getCoreActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getAiActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getApiKeyValidationActionProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getFileActionProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getKeyValueStoreActionProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getQueueActionProcessor(qpqConfig, dynamicModuleLoader)),
@@ -26,4 +33,5 @@ export const getCoreActionProcessor = async (qpqConfig, dynamicModuleLoader) =>
     ...(await getConfigActionProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getApiGatewayApiEventEventProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getGraphDatabaseActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getRouteAuthValidationActionProcessor(qpqConfig, dynamicModuleLoader)),
 });

package/lib/esm/getActionProcessor/core/queue/getQueueSendMessageActionProcessor.js

@@ -3,17 +3,14 @@ import { actionResult, QueueActionType } from 'quidproquo-core';
 import { sendMessages } from '../../../logic/sqs/sendMessages';
 import { resolveResourceName } from '../../../runtimeConfig/qpqAwsLambdaRuntimeConfigUtils';
 const getProcessQueueSendMessage = (qpqConfig) => {
-    return async ({ queueName, queueMessages, context }, session) => {
+    return async ({ queueName, queueMessages }, session) => {
         // While we have some uuids
         const sqsQueueName = resolveResourceName(queueName, qpqConfig);
         await sendMessages(sqsQueueName, qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig), queueMessages.map((message) => {
             // Add the session info to the message
             const queueMessageWithSession = {
                 ...message,
-                storySession: {
-                    ...session,
-                    context,
-                },
+                storySession: session,
             };
             return JSON.stringify(queueMessageWithSession);
         }));

package/lib/esm/getActionProcessor/core/userDirectory/getUserDirectoryCreateUserActionProcessor.js

@@ -1,14 +1,19 @@
 import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
-import { actionResult, UserDirectoryActionType, } from 'quidproquo-core';
+import { actionResult, actionResultError, ErrorTypeEnum, UserDirectoryActionType, } from 'quidproquo-core';
 import { getCFExportNameUserPoolClientIdFromConfig, getCFExportNameUserPoolIdFromConfig } from '../../../awsNamingUtils';
 import { getExportedValue } from '../../../logic/cloudformation/getExportedValue';
 import { createUser } from '../../../logic/cognito/createUser';
+import { resolveUsernameByPreferredUsername } from '../../../logic/cognito/resolveUsernameByPreferredUsername';
 const getProcessCreateUser = (qpqConfig) => {
     return async (payload) => {
         const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
         const userPoolId = await getExportedValue(getCFExportNameUserPoolIdFromConfig(payload.userDirectoryName, qpqConfig), region);
         const userPoolClientId = await getExportedValue(getCFExportNameUserPoolClientIdFromConfig(payload.userDirectoryName, qpqConfig), region);
-        const authResponse = await createUser(userPoolId, qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig), userPoolClientId, payload.createUserRequest);
+        const resolvedUsername = await resolveUsernameByPreferredUsername(userPoolId, region, payload.createUserRequest.email);
+        if (resolvedUsername !== payload.createUserRequest.email) {
+            return actionResultError(ErrorTypeEnum.Conflict, 'An account with this email already exists');
+        }
+        const authResponse = await createUser(userPoolId, region, userPoolClientId, payload.createUserRequest);
         return actionResult(authResponse);
     };
 };

package/lib/esm/getActionProcessor/webserver/serviceFunction/getServiceFunctionExecuteActionProcessor.js

@@ -4,7 +4,7 @@ import { ServiceFunctionActionType } from 'quidproquo-webserver';
 import { getConfigRuntimeResourceName } from '../../../awsNamingUtils';
 import { executeLambdaByName } from '../../../logic/lambda/executeLambdaByName';
 const getProcessExecute = (qpqConfig) => {
-    return async ({ functionName, service, payload, context, isAsync }, session) => {
+    return async ({ functionName, service, payload, isAsync }, session) => {
         const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
         const appName = qpqCoreUtils.getApplicationName(qpqConfig);
         const environment = qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig);
@@ -13,10 +13,7 @@ const getProcessExecute = (qpqConfig) => {
         const serviceFunctionEvent = {
             functionName: functionName,
             payload: payload,
-            storySession: {
-                ...session,
-                context,
-            },
+            storySession: session,
         };
         const result = await executeLambdaByName(awsFunctionName, region, serviceFunctionEvent, isAsync);
         if (!result) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quidproquo-actionprocessor-awslambda",
-  "version": "0.0.261",
+  "version": "0.0.263",
   "description": "",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/esm/index.js",
@@ -32,6 +32,7 @@
   },
   "homepage": "https://github.com/joe-coady/quidproquo#readme",
   "dependencies": {
+    "@ai-sdk/amazon-bedrock": "^4.0.83",
     "@aws-sdk/client-acm": "^3.744.0",
     "@aws-sdk/client-api-gateway": "^3.744.0",
     "@aws-sdk/client-apigatewaymanagementapi": "^3.744.0",
@@ -50,6 +51,7 @@
     "@aws-sdk/s3-presigned-post": "^3.744.0",
     "@aws-sdk/s3-request-presigner": "^3.744.0",
     "@types/aws-lambda": "^8.10.109",
+    "ai": "^6.0.141",
     "aws-jwt-verify": "^3.4.0",
     "busboy": "^1.6.0",
     "jsonwebtoken": "^9.0.0",
@@ -57,16 +59,16 @@
     "lodash": "^4.17.21",
     "node-cache": "^5.1.2",
     "node-match-path": "^0.6.3",
-    "quidproquo-config-aws": "0.0.261",
-    "quidproquo-core": "0.0.261",
-    "quidproquo-webserver": "0.0.261"
+    "quidproquo-config-aws": "0.0.263",
+    "quidproquo-core": "0.0.263",
+    "quidproquo-webserver": "0.0.263"
   },
   "devDependencies": {
     "@types/busboy": "^1.5.0",
     "@types/jsonwebtoken": "^9.0.2",
     "@types/lodash": "^4.14.194",
     "@types/node": "^22.13.13",
-    "quidproquo-tsconfig": "0.0.261",
+    "quidproquo-tsconfig": "0.0.263",
     "typescript": "^5.8.2"
   }
 }

package/lib/commonjs/getActionProcessor/core/event/utils/isAuthValid.d.ts

@@ -1,3 +0,0 @@
-import { QPQConfig } from 'quidproquo-core';
-import { RouteAuthSettings } from 'quidproquo-webserver';
-export declare const isAuthValid: (qpqConfig: QPQConfig, authHeader?: string | null, apiKeyHeader?: string | null, authSettings?: RouteAuthSettings) => Promise<boolean>;