@wundam/orchex 1.0.0-rc.2 → 1.0.0-rc.21

package/dist/executors/bedrock-executor.js

@@ -0,0 +1,197 @@
+/**
+ * AWS Bedrock Executor
+ *
+ * Supports Claude (via Bedrock), Llama, and Mistral models.
+ * Auth via AWS credentials (access key + secret key, or IAM role).
+ */
+import { DEFAULT_EXECUTOR_CONFIG, RETRYABLE_STATUS_CODES, sleep, TimeoutError, withCircuitBreaker } from './base.js';
+import { extractArtifactWithDiagnostics } from '../artifacts.js';
+import { Semaphore } from '../semaphore.js';
+// ============================================================================
+// Model ID Mapping
+// ============================================================================
+const BEDROCK_MODEL_MAP = {
+    'claude-3.5-sonnet': 'anthropic.claude-3-5-sonnet-20241022-v2:0',
+    'claude-3-haiku': 'anthropic.claude-3-haiku-20240307-v1:0',
+    'claude-sonnet-4-5': 'anthropic.claude-sonnet-4-5-v1:0',
+    'llama-3.1-70b': 'meta.llama3-1-70b-instruct-v1:0',
+    'mistral-large': 'mistral.mistral-large-2407-v1:0',
+};
+export function resolveBedrockModelId(model) {
+    return BEDROCK_MODEL_MAP[model] ?? model;
+}
+function isClaudeModel(modelId) {
+    return modelId.startsWith('anthropic.');
+}
+function isLlamaModel(modelId) {
+    return modelId.startsWith('meta.');
+}
+const DEFAULT_BEDROCK_CONFIG = {
+    ...DEFAULT_EXECUTOR_CONFIG,
+    region: process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1',
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+};
+// ============================================================================
+// Executor
+// ============================================================================
+export class BedrockExecutor {
+    provider = 'bedrock';
+    config;
+    semaphore;
+    client;
+    constructor(config, client) {
+        this.config = { ...DEFAULT_BEDROCK_CONFIG, ...config };
+        this.semaphore = new Semaphore(this.config.maxConcurrency);
+        this.client = client;
+    }
+    async getClient() {
+        if (this.client)
+            return this.client;
+        // Dynamic import to avoid requiring @aws-sdk in non-Bedrock users
+        const { BedrockRuntimeClient, InvokeModelCommand } = await import('@aws-sdk/client-bedrock-runtime');
+        const awsClient = new BedrockRuntimeClient({
+            region: this.config.region,
+            ...(this.config.accessKeyId && this.config.secretAccessKey
+                ? {
+                    credentials: {
+                        accessKeyId: this.config.accessKeyId,
+                        secretAccessKey: this.config.secretAccessKey,
+                    },
+                }
+                : {}),
+        });
+        this.client = {
+            async invokeModel(params) {
+                const command = new InvokeModelCommand({
+                    modelId: params.modelId,
+                    contentType: params.contentType,
+                    accept: params.accept,
+                    body: new TextEncoder().encode(params.body),
+                });
+                const response = await awsClient.send(command);
+                return {
+                    body: response.body ?? new Uint8Array(),
+                    contentType: response.contentType,
+                };
+            },
+        };
+        return this.client;
+    }
+    async execute(request) {
+        const release = await this.semaphore.acquire();
+        try {
+            return await withCircuitBreaker(this.provider, request.model, () => this.executeWithRetry(request));
+        }
+        catch (err) {
+            return {
+                success: false,
+                rawResponse: '',
+                tokensUsed: { input: 0, output: 0 },
+                error: err?.message ?? String(err),
+            };
+        }
+        finally {
+            release();
+        }
+    }
+    async executeWithRetry(request) {
+        const modelId = resolveBedrockModelId(request.model);
+        for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
+            try {
+                return await this.invokeWithTimeout(request, modelId);
+            }
+            catch (err) {
+                const statusCode = err?.statusCode ?? err?.$metadata?.httpStatusCode;
+                if (statusCode && RETRYABLE_STATUS_CODES.has(statusCode) && attempt < this.config.maxRetries) {
+                    await sleep(this.config.retryDelayMs * Math.pow(2, attempt));
+                    continue;
+                }
+                throw err;
+            }
+        }
+        throw new Error('Max retries exceeded');
+    }
+    async invokeWithTimeout(request, modelId) {
+        const timeoutMs = request.timeoutMs ?? this.config.timeoutMs;
+        const resultPromise = this.invokeModel(request, modelId);
+        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new TimeoutError(timeoutMs)), timeoutMs));
+        return Promise.race([resultPromise, timeoutPromise]);
+    }
+    async invokeModel(request, modelId) {
+        const client = await this.getClient();
+        const body = this.buildRequestBody(request, modelId);
+        const response = await client.invokeModel({
+            modelId,
+            contentType: 'application/json',
+            accept: 'application/json',
+            body: JSON.stringify(body),
+        });
+        const responseBody = typeof response.body === 'string'
+            ? JSON.parse(response.body)
+            : JSON.parse(new TextDecoder().decode(response.body));
+        return this.parseResponse(responseBody, modelId, request.streamId);
+    }
+    buildRequestBody(request, modelId) {
+        if (isClaudeModel(modelId)) {
+            return {
+                anthropic_version: 'bedrock-2023-05-31',
+                max_tokens: request.maxTokens,
+                messages: [{ role: 'user', content: request.prompt }],
+            };
+        }
+        if (isLlamaModel(modelId)) {
+            return {
+                prompt: request.prompt,
+                max_gen_len: request.maxTokens,
+                temperature: 0.1,
+            };
+        }
+        // Mistral and others
+        return {
+            prompt: `<s>[INST] ${request.prompt} [/INST]`,
+            max_tokens: request.maxTokens,
+            temperature: 0.1,
+        };
+    }
+    parseResponse(body, modelId, streamId) {
+        let rawText;
+        let tokensUsed = { input: 0, output: 0 };
+        if (isClaudeModel(modelId)) {
+            rawText = body.content?.[0]?.text ?? '';
+            tokensUsed = {
+                input: body.usage?.input_tokens ?? 0,
+                output: body.usage?.output_tokens ?? 0,
+            };
+        }
+        else if (isLlamaModel(modelId)) {
+            rawText = body.generation ?? '';
+            tokensUsed = {
+                input: body.prompt_token_count ?? 0,
+                output: body.generation_token_count ?? 0,
+            };
+        }
+        else {
+            // Mistral
+            rawText = body.outputs?.[0]?.text ?? '';
+            // Mistral on Bedrock doesn't always return token counts
+            tokensUsed = { input: 0, output: 0 };
+        }
+        let artifact;
+        try {
+            const extraction = extractArtifactWithDiagnostics(rawText);
+            if (extraction.artifact) {
+                artifact = extraction.artifact;
+            }
+        }
+        catch {
+            // Extraction failure — return raw response
+        }
+        return {
+            success: true,
+            rawResponse: rawText,
+            artifact,
+            tokensUsed,
+        };
+    }
+}

package/dist/executors/index.d.ts

@@ -11,6 +11,7 @@ export { OpenAIExecutor } from './openai-executor.js';
 export { GeminiExecutor } from './gemini-executor.js';
 export { OllamaExecutor } from './ollama-executor.js';
 export { DeepseekExecutor } from './deepseek-executor.js';
+export { BedrockExecutor } from './bedrock-executor.js';
 export * from './base.js';
 /**
  * Options for creating an executor.

package/dist/executors/index.js

@@ -10,12 +10,14 @@ import { OpenAIExecutor } from './openai-executor.js';
 import { GeminiExecutor } from './gemini-executor.js';
 import { OllamaExecutor } from './ollama-executor.js';
 import { DeepseekExecutor } from './deepseek-executor.js';
+import { BedrockExecutor } from './bedrock-executor.js';
 // Re-export individual executors
 export { ClaudeExecutor } from '../claude-executor.js';
 export { OpenAIExecutor } from './openai-executor.js';
 export { GeminiExecutor } from './gemini-executor.js';
 export { OllamaExecutor } from './ollama-executor.js';
 export { DeepseekExecutor } from './deepseek-executor.js';
+export { BedrockExecutor } from './bedrock-executor.js';
 // Re-export base utilities
 export * from './base.js';
 /**
@@ -88,8 +90,15 @@ export function createExecutor(options = {}) {
                 timeoutMs: options.timeoutMs,
                 maxConcurrency: options.maxConcurrency,
             }));
+        case 'bedrock':
+            return new BedrockExecutor(defined({
+                maxRetries: options.maxRetries,
+                retryDelayMs: options.retryDelayMs,
+                timeoutMs: options.timeoutMs,
+                maxConcurrency: options.maxConcurrency,
+            }));
         default:
-            throw new Error(`Unknown provider: ${provider}. Supported: anthropic, openai, gemini, ollama, deepseek`);
+            throw new Error(`Unknown provider: ${provider}. Supported: anthropic, openai, gemini, ollama, deepseek, bedrock`);
     }
 }
 /**
@@ -106,6 +115,7 @@ export function getProviderStatus() {
         gemini: 'Google Gemini',
         ollama: 'Ollama (local)',
         deepseek: 'DeepSeek',
+        bedrock: 'AWS Bedrock',
     };
     if (provider === 'ollama') {
         return {
@@ -114,6 +124,16 @@ export function getProviderStatus() {
             message: `Provider: ${providerNames[provider]} at ${baseUrl}`,
         };
     }
+    if (provider === 'bedrock') {
+        const hasCredentials = !!(process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY);
+        return {
+            provider,
+            configured: hasCredentials,
+            message: hasCredentials
+                ? `Provider: ${providerNames[provider]} (${process.env.AWS_REGION ?? 'us-east-1'})`
+                : `Provider: ${providerNames[provider]} (not configured - missing AWS credentials)`,
+        };
+    }
     if (!apiKey) {
         return {
             provider,
@@ -142,6 +162,8 @@ export function listConfiguredProviders() {
         configured.push('gemini');
     if (process.env.DEEPSEEK_API_KEY)
         configured.push('deepseek');
+    if (process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY)
+        configured.push('bedrock');
     if (process.env.OLLAMA_BASE_URL || process.env.OLLAMA_HOST)
         configured.push('ollama');
     // Ollama is always available if running locally (default port)
@@ -166,6 +188,7 @@ export async function getFullStatus() {
         gemini: 'Google Gemini',
         ollama: 'Ollama (local)',
         deepseek: 'DeepSeek',
+        bedrock: 'AWS Bedrock',
     };
     if (provider === 'ollama') {
         return {