@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/service/localServiceOpen.js

@@ -0,0 +1,27 @@
+import { discoverOrStartLocalService } from './localServiceClientLifecycle.js';
+export function shouldOpenViaLocalService(env) {
+    const configured = String(env.TASKFORCE_SHARED_LOCAL_MCP_ENABLED || '').trim();
+    return !configured || /^(1|true|yes|on)$/i.test(configured);
+}
+export function buildLocalServiceUiUrl(descriptor) {
+    const url = new URL('/taskforce/', descriptor.endpoint);
+    // The service endpoint is process-internal and may use an ephemeral port,
+    // but the browser hostname must remain stable so localhost auth cookies
+    // survive shared-service restarts.
+    url.hostname = 'localhost';
+    return url.toString();
+}
+export async function openTaskforceViaLocalService(input) {
+    const descriptor = await (input.discover || discoverOrStartLocalService)({
+        projectRoot: input.projectRoot,
+        env: input.env,
+        executablePath: input.executablePath,
+        cliEntryPath: input.cliEntryPath,
+        execArgv: input.execArgv,
+    });
+    const url = buildLocalServiceUiUrl(descriptor);
+    input.log?.(`Taskforce shared service ready at ${descriptor.endpoint}.`);
+    input.log?.(`Opening ${url}...`);
+    input.openBrowser(url);
+    return { descriptor, url };
+}

package/dist/services/agentRoleResolver.d.ts

@@ -0,0 +1,4 @@
+import type { BehaviorReference } from '../shared/taskforceAgentDefinition.js';
+import type { ResolvedAgentConfigurationReference } from '../shared/taskforceAgentRuntimeResolution.js';
+import type { AgentRoleStore } from '../storage/agentRoleStore.js';
+export declare function createAgentRoleBehaviorReferenceResolver(store: AgentRoleStore, workspaceId: string): (kind: 'role' | 'skill', reference: BehaviorReference) => ResolvedAgentConfigurationReference | null;

package/dist/services/agentRoleResolver.js

@@ -0,0 +1,7 @@
+export function createAgentRoleBehaviorReferenceResolver(store, workspaceId) {
+    return (kind, reference) => {
+        if (kind !== 'role')
+            return null;
+        return store.resolve(workspaceId, reference);
+    };
+}

package/dist/services/aiProfileAvatarGenerationService.d.ts

@@ -0,0 +1,41 @@
+import type { TaskforceCore } from '../core/Taskforce.js';
+import type { AiProfileAvatarAssetDeps } from '../server/aiProfileAvatarAssets.js';
+import type { AvatarImageProvider } from './avatarImageProvider.js';
+type AiProfileRecord = ReturnType<TaskforceCore['listAiProfiles']>[number];
+export interface AvatarGenerationRateLimitResult {
+    allowed: boolean;
+    retryAfterSeconds?: number;
+}
+export declare function createAiProfileAvatarRateLimitChecker(profileLimit: number, workspaceLimit: number, windowMs: number): (profile: AiProfileRecord) => AvatarGenerationRateLimitResult;
+export declare const checkAiProfileAvatarGenerationRateLimit: (profile: AiProfileRecord) => AvatarGenerationRateLimitResult;
+export interface AiProfileAvatarGenerationDeps {
+    core: TaskforceCore;
+    avatarAssetDeps: AiProfileAvatarAssetDeps;
+    imageProvider: AvatarImageProvider;
+    checkRateLimit?: (profile: AiProfileRecord) => AvatarGenerationRateLimitResult;
+}
+export interface GenerateAiProfileAvatarInput {
+    workspaceId: string;
+    profileId: string;
+    actorId?: string | null;
+    visualDirection?: string | null;
+    replaceExisting?: boolean;
+}
+export declare class AiProfileAvatarGenerationError extends Error {
+    readonly code: string;
+    readonly statusCode: number;
+    readonly retryAfterSeconds?: number;
+    constructor(message: string, code: string, statusCode: number, retryAfterSeconds?: number);
+}
+export declare function buildAiProfileAvatarPrompt(input: {
+    profile: AiProfileRecord;
+    visualDirection?: string | null;
+}): string;
+export declare function generateAiProfileAvatar(deps: AiProfileAvatarGenerationDeps, input: GenerateAiProfileAvatarInput): Promise<{
+    profile: import("../core/Taskforce.js").AiProfileRecord;
+    replacedExisting: boolean;
+    modelId: string;
+    displayStorageKey: string;
+    sourceStorageKey: string;
+}>;
+export {};

package/dist/services/aiProfileAvatarGenerationService.js

@@ -0,0 +1,158 @@
+import { AiProfileAvatarStateConflictError, saveAiProfileAvatarAssets } from '../server/aiProfileAvatarAssets.js';
+import { InMemoryRateLimiter } from '../server/rateLimit.js';
+import { isAiProfileAvatarGenerationEligible } from '../shared/aiProfileAvatarEligibility.js';
+import { trimAvatarPromptForModel } from './avatarImageProvider.js';
+import sharp from 'sharp';
+const avatarRateLimitWindowMs = Math.max(60_000, Number.parseInt(process.env.TASKFORCE_AI_AVATAR_RATE_LIMIT_WINDOW_MS || '', 10) || 3_600_000);
+export function createAiProfileAvatarRateLimitChecker(profileLimit, workspaceLimit, windowMs) {
+    const profileLimiter = new InMemoryRateLimiter(profileLimit, windowMs);
+    const workspaceLimiter = new InMemoryRateLimiter(workspaceLimit, windowMs);
+    return (profile) => {
+        const now = Date.now();
+        const profileKey = `${profile.workspaceId}:${profile.id}`;
+        const profileResult = profileLimiter.peek(profileKey, now);
+        const workspaceResult = workspaceLimiter.peek(profile.workspaceId, now);
+        if (!profileResult.allowed || !workspaceResult.allowed) {
+            return {
+                allowed: false,
+                retryAfterSeconds: Math.max(profileResult.retryAfterSeconds, workspaceResult.retryAfterSeconds),
+            };
+        }
+        profileLimiter.check(profileKey, now);
+        workspaceLimiter.check(profile.workspaceId, now);
+        return { allowed: true };
+    };
+}
+export const checkAiProfileAvatarGenerationRateLimit = createAiProfileAvatarRateLimitChecker(Number.parseInt(process.env.TASKFORCE_AI_AVATAR_PROFILE_LIMIT || '', 10) || 3, Number.parseInt(process.env.TASKFORCE_AI_AVATAR_WORKSPACE_LIMIT || '', 10) || 20, avatarRateLimitWindowMs);
+export class AiProfileAvatarGenerationError extends Error {
+    code;
+    statusCode;
+    retryAfterSeconds;
+    constructor(message, code, statusCode, retryAfterSeconds) {
+        super(message);
+        this.name = 'AiProfileAvatarGenerationError';
+        this.code = code;
+        this.statusCode = statusCode;
+        this.retryAfterSeconds = retryAfterSeconds;
+    }
+}
+function normalizePromptField(value, maxLength) {
+    return String(value || '').replace(/\s+/g, ' ').trim().slice(0, maxLength);
+}
+export function buildAiProfileAvatarPrompt(input) {
+    const name = normalizePromptField(input.profile.name, 80) || 'AI collaborator';
+    const role = normalizePromptField(input.profile.role, 100);
+    const description = normalizePromptField(input.profile.description, 240);
+    const provider = normalizePromptField(input.profile.provider, 80);
+    const model = normalizePromptField(input.profile.model, 100);
+    const visualDirection = normalizePromptField(input.visualDirection, 300);
+    const fixedInstructions = [
+        'Square product avatar portrait for a fictional AI collaborator.',
+        'Not a real person. No text, letters, numbers, watermark, brand marks, product logos, provider logos, or UI chrome.',
+        'Clean modern assistant character, friendly professional expression, simple background, high contrast, centered head and shoulders.',
+    ].join(' ');
+    const technology = [provider, model].filter(Boolean).join(' ');
+    const mutableDetails = [
+        `Name: ${name}.`,
+        visualDirection ? `Visual direction: ${visualDirection}.` : '',
+        role ? `Role: ${role}.` : '',
+        description ? `Character description: ${description}.` : '',
+        technology ? `Subtle visual inspiration from ${technology}, without using any product or provider logo.` : '',
+    ].filter(Boolean).join(' ');
+    const remainingCharacters = Math.max(0, 512 - fixedInstructions.length - 1);
+    return trimAvatarPromptForModel(`${fixedInstructions} ${mutableDetails.slice(0, remainingCharacters)}`);
+}
+async function validateGeneratedAvatarImage(buffer) {
+    try {
+        const image = sharp(buffer, { animated: true, limitInputPixels: 16_777_216 });
+        const metadata = await image.metadata();
+        if (!metadata.width || !metadata.height || metadata.format !== 'png')
+            throw new Error('Invalid generated PNG metadata.');
+        await image.clone().rotate().resize({ width: 1, height: 1 }).raw().toBuffer();
+    }
+    catch {
+        throw new AiProfileAvatarGenerationError('Avatar generation returned an invalid image. Please try again.', 'AI_PROFILE_AVATAR_PROVIDER_FAILED', 502);
+    }
+}
+const activeGenerations = new Set();
+export async function generateAiProfileAvatar(deps, input) {
+    const workspaceId = String(input.workspaceId || '').trim();
+    const profileId = String(input.profileId || '').trim();
+    const profile = deps.core.listAiProfiles(workspaceId).find((candidate) => candidate.id === profileId);
+    if (!profile) {
+        throw new AiProfileAvatarGenerationError('AI profile not found.', 'AI_PROFILE_AVATAR_PROFILE_NOT_FOUND', 404);
+    }
+    if (!isAiProfileAvatarGenerationEligible(profile)) {
+        throw new AiProfileAvatarGenerationError('Generated avatars are available only for active external agent profiles.', 'AI_PROFILE_AVATAR_NOT_ELIGIBLE', 409);
+    }
+    const replacing = Boolean(profile.avatarUrl);
+    if (replacing && input.replaceExisting !== true) {
+        throw new AiProfileAvatarGenerationError('This profile already has a custom avatar. Confirm replacement and try again.', 'AI_PROFILE_AVATAR_REPLACE_CONFIRMATION_REQUIRED', 409);
+    }
+    const generationKey = `${workspaceId}:${profileId}`;
+    if (activeGenerations.has(generationKey)) {
+        throw new AiProfileAvatarGenerationError('Avatar generation is already in progress for this profile.', 'AI_PROFILE_AVATAR_GENERATION_IN_PROGRESS', 409);
+    }
+    activeGenerations.add(generationKey);
+    try {
+        const rateLimit = deps.checkRateLimit?.(profile);
+        if (rateLimit && !rateLimit.allowed) {
+            throw new AiProfileAvatarGenerationError('Avatar generation limit reached. Try again later.', 'AI_PROFILE_AVATAR_RATE_LIMITED', 429, rateLimit.retryAfterSeconds);
+        }
+        let generated;
+        try {
+            generated = await deps.imageProvider.generate(buildAiProfileAvatarPrompt({
+                profile,
+                visualDirection: input.visualDirection,
+            }));
+            await validateGeneratedAvatarImage(generated.buffer);
+        }
+        catch (error) {
+            const raw = String(error?.message || error || 'Avatar generation failed.');
+            const message = /^\s*(?:<!doctype\s+html|<html\b)/i.test(raw)
+                ? 'Avatar generation is temporarily unavailable. Please try again.'
+                : 'Avatar generation failed. Please try again.';
+            throw new AiProfileAvatarGenerationError(message, 'AI_PROFILE_AVATAR_PROVIDER_FAILED', 502);
+        }
+        let result;
+        try {
+            result = await saveAiProfileAvatarAssets(deps.avatarAssetDeps, {
+                workspaceId,
+                profileId,
+                display: {
+                    buffer: generated.buffer,
+                    mimeType: generated.mimeType,
+                    originalName: `${profile.username || 'ai-profile'}-generated-avatar.png`,
+                },
+                source: {
+                    buffer: generated.buffer,
+                    mimeType: generated.mimeType,
+                    originalName: `${profile.username || 'ai-profile'}-generated-avatar-source.png`,
+                },
+                actorId: input.actorId,
+                expectedProfileState: {
+                    avatarRevision: Number(profile.avatarRevision || 0),
+                    avatarUrl: profile.avatarUrl || null,
+                    avatarSourceUrl: profile.avatarSourceUrl || null,
+                    requireGenerationEligibility: true,
+                },
+            });
+        }
+        catch (error) {
+            if (error instanceof AiProfileAvatarStateConflictError) {
+                throw new AiProfileAvatarGenerationError('This profile changed while its avatar was being generated. Review the current profile and try again.', 'AI_PROFILE_AVATAR_STATE_CHANGED', 409);
+            }
+            throw new AiProfileAvatarGenerationError('The generated avatar could not be saved. Your previous avatar was preserved.', 'AI_PROFILE_AVATAR_PERSISTENCE_FAILED', 500);
+        }
+        return {
+            profile: result.profile,
+            replacedExisting: replacing,
+            modelId: generated.modelId,
+            displayStorageKey: result.displayStorageKey,
+            sourceStorageKey: result.sourceStorageKey,
+        };
+    }
+    finally {
+        activeGenerations.delete(generationKey);
+    }
+}

package/dist/services/avatarImageProvider.d.ts

@@ -0,0 +1,33 @@
+import { InvokeModelCommand, type InvokeModelCommandOutput } from '@aws-sdk/client-bedrock-runtime';
+export interface AvatarImage {
+    buffer: Buffer;
+    mimeType: 'image/png';
+    modelId: string;
+}
+export interface AvatarImageProvider {
+    generate(prompt: string): Promise<AvatarImage>;
+    getDiagnostics?(): Record<string, string>;
+}
+type BedrockImageClient = {
+    send(command: InvokeModelCommand, options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<InvokeModelCommandOutput>;
+};
+export interface BedrockAvatarImageProviderOptions {
+    client?: BedrockImageClient;
+    region?: string;
+    modelId?: string;
+    timeoutMs?: number;
+}
+export declare function trimAvatarPromptForModel(prompt: string, maxLength?: number): string;
+export declare class BedrockAvatarImageProvider implements AvatarImageProvider {
+    private readonly client;
+    private readonly modelId;
+    private readonly region;
+    private readonly timeoutMs;
+    constructor(options?: BedrockAvatarImageProviderOptions);
+    getDiagnostics(): Record<string, string>;
+    generate(prompt: string): Promise<AvatarImage>;
+    private invoke;
+}
+export {};

package/dist/services/avatarImageProvider.js

@@ -0,0 +1,140 @@
+import { BedrockRuntimeClient, InvokeModelCommand, } from '@aws-sdk/client-bedrock-runtime';
+const DEFAULT_BEDROCK_AVATAR_MODEL_ID = 'stability.stable-image-core-v1:1';
+const DEFAULT_BEDROCK_AVATAR_TIMEOUT_MS = 120_000;
+const MAX_BEDROCK_AVATAR_SEED = 858_993_459;
+const TITAN_MAX_PROMPT_CHARS = 512;
+const STABILITY_MAX_SEED = 4_294_967_295;
+function readUtf8Body(body) {
+    if (!body)
+        return '';
+    return new TextDecoder().decode(body);
+}
+function randomSeed() {
+    return Math.floor(Math.random() * (MAX_BEDROCK_AVATAR_SEED + 1));
+}
+function randomStabilitySeed() {
+    return Math.floor(Math.random() * (STABILITY_MAX_SEED + 1));
+}
+export function trimAvatarPromptForModel(prompt, maxLength = TITAN_MAX_PROMPT_CHARS) {
+    const normalized = String(prompt || '').replace(/\s+/g, ' ').trim();
+    if (normalized.length <= maxLength)
+        return normalized;
+    return normalized.slice(0, maxLength - 1).trimEnd();
+}
+function buildTitanPayload(prompt) {
+    return {
+        taskType: 'TEXT_IMAGE',
+        textToImageParams: {
+            text: trimAvatarPromptForModel(prompt),
+            negativeText: 'text, letters, numbers, watermark, logo, brand mark, user interface, dark background',
+        },
+        imageGenerationConfig: {
+            seed: randomSeed(),
+            quality: 'standard',
+            width: 512,
+            height: 512,
+            numberOfImages: 1,
+            cfgScale: 7,
+        },
+    };
+}
+function buildStabilityPayload(prompt) {
+    return {
+        prompt: trimAvatarPromptForModel(prompt, 10_000),
+        aspect_ratio: '1:1',
+        output_format: 'png',
+        seed: randomStabilitySeed(),
+        negative_prompt: 'text, letters, numbers, watermark, logo, brand mark, user interface, dark background',
+    };
+}
+function createTimeoutSignal(timeoutMs) {
+    if (typeof AbortSignal !== 'undefined' && typeof AbortSignal.timeout === 'function') {
+        return AbortSignal.timeout(timeoutMs);
+    }
+    return undefined;
+}
+function normalizeBedrockAvatarModelId(modelId) {
+    const normalized = modelId.trim();
+    return normalized === 'stability.stable-image-core-v1:0'
+        ? DEFAULT_BEDROCK_AVATAR_MODEL_ID
+        : normalized;
+}
+function buildBedrockImagePayload(modelId, prompt) {
+    if (modelId.startsWith('stability.') || modelId.includes('.stability.')) {
+        return buildStabilityPayload(prompt);
+    }
+    if (modelId.startsWith('amazon.nova-canvas-')) {
+        return {
+            taskType: 'TEXT_IMAGE',
+            textToImageParams: { text: trimAvatarPromptForModel(prompt) },
+            imageGenerationConfig: {
+                seed: randomSeed(),
+                quality: 'standard',
+                width: 512,
+                height: 512,
+                numberOfImages: 1,
+            },
+        };
+    }
+    return buildTitanPayload(prompt);
+}
+function parseBedrockImage(response, modelId) {
+    const decoded = readUtf8Body(response.body);
+    const payload = JSON.parse(decoded || '{}');
+    const firstImage = Array.isArray(payload.images) ? payload.images[0] : null;
+    if (typeof firstImage !== 'string' || !firstImage.trim()) {
+        throw new Error(String(payload.error || payload.message || 'Image generation did not return an avatar image.').trim());
+    }
+    return { buffer: Buffer.from(firstImage, 'base64'), mimeType: 'image/png', modelId };
+}
+function isResponsibleAiBlock(error) {
+    const message = String(error?.message || error || '').toLowerCase();
+    return message.includes('responsible ai')
+        || message.includes('rai')
+        || message.includes('blocked')
+        || message.includes('safety');
+}
+export class BedrockAvatarImageProvider {
+    client;
+    modelId;
+    region;
+    timeoutMs;
+    constructor(options = {}) {
+        this.modelId = normalizeBedrockAvatarModelId(options.modelId
+            || String(process.env.AWS_BEDROCK_AVATAR_MODEL_ID || '').trim()
+            || String(process.env.TASKFORCE_AVATAR_NOVA_MODEL_ID || '').trim()
+            || DEFAULT_BEDROCK_AVATAR_MODEL_ID);
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_BEDROCK_AVATAR_TIMEOUT_MS;
+        this.region = options.region
+            || process.env.AWS_REGION_AVATAR_GENERATION
+            || process.env.AWS_REGION
+            || process.env.AWS_DEFAULT_REGION
+            || 'us-east-1';
+        this.client = options.client ?? new BedrockRuntimeClient({ region: this.region });
+    }
+    getDiagnostics() {
+        return { provider: 'bedrock', region: this.region, modelId: this.modelId };
+    }
+    async generate(prompt) {
+        const normalizedPrompt = String(prompt || '').trim();
+        if (!normalizedPrompt)
+            throw new Error('Avatar prompt is required.');
+        try {
+            return await this.invoke(normalizedPrompt);
+        }
+        catch (error) {
+            if (!isResponsibleAiBlock(error))
+                throw error;
+            return this.invoke(`${normalizedPrompt} Use a safer abstract geometric assistant character if the portrait request is restricted.`);
+        }
+    }
+    async invoke(prompt) {
+        const response = await this.client.send(new InvokeModelCommand({
+            modelId: this.modelId,
+            contentType: 'application/json',
+            accept: 'application/json',
+            body: JSON.stringify(buildBedrockImagePayload(this.modelId, prompt)),
+        }), { abortSignal: createTimeoutSignal(this.timeoutMs) });
+        return parseBedrockImage(response, this.modelId);
+    }
+}

package/dist/services/bedrockAnthropicMessagesModelGateway.d.ts

@@ -0,0 +1,24 @@
+import { InvokeModelCommand, type InvokeModelCommandOutput } from '@aws-sdk/client-bedrock-runtime';
+import type { ModelGateway, ModelGatewayGenerateInput, ModelGatewayGenerateResult } from './modelGateway.js';
+type BedrockInvokeModelClient = {
+    send(command: InvokeModelCommand): Promise<InvokeModelCommandOutput>;
+};
+export type BedrockAnthropicMessagesModelKeyIdMap = Partial<Record<string, string>>;
+export interface BedrockAnthropicMessagesModelGatewayOptions {
+    client?: BedrockInvokeModelClient;
+    region?: string;
+    modelKeyIds?: BedrockAnthropicMessagesModelKeyIdMap;
+}
+export declare const DEFAULT_BEDROCK_ANTHROPIC_MESSAGES_MODEL_KEY_IDS: BedrockAnthropicMessagesModelKeyIdMap;
+export declare class BedrockAnthropicMessagesModelGateway implements ModelGateway {
+    private readonly client;
+    private readonly modelKeyIds;
+    constructor(options?: BedrockAnthropicMessagesModelGatewayOptions);
+    generate(input: ModelGatewayGenerateInput): Promise<ModelGatewayGenerateResult>;
+    private resolveModelId;
+    private buildRequestBody;
+    private readUtf8Body;
+    private extractText;
+    private readNumber;
+}
+export {};

package/dist/services/bedrockAnthropicMessagesModelGateway.js

@@ -0,0 +1,95 @@
+import { BedrockRuntimeClient, InvokeModelCommand, } from '@aws-sdk/client-bedrock-runtime';
+import { TASKFORCE_AGENT_MODEL_OPTIONS } from '../shared/taskforceAgentModels.js';
+export const DEFAULT_BEDROCK_ANTHROPIC_MESSAGES_MODEL_KEY_IDS = {
+    ...Object.fromEntries(TASKFORCE_AGENT_MODEL_OPTIONS
+        .filter((model) => model.runtime === 'bedrock-anthropic-messages')
+        .map((model) => [model.key, model.runtimeModelId])),
+};
+export class BedrockAnthropicMessagesModelGateway {
+    client;
+    modelKeyIds;
+    constructor(options = {}) {
+        this.client = options.client ?? new BedrockRuntimeClient({
+            region: options.region ?? process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-west-2',
+        });
+        this.modelKeyIds = {
+            ...DEFAULT_BEDROCK_ANTHROPIC_MESSAGES_MODEL_KEY_IDS,
+            ...(options.modelKeyIds ?? {}),
+        };
+    }
+    async generate(input) {
+        const modelId = this.resolveModelId(input);
+        const startedAt = Date.now();
+        const response = await this.client.send(new InvokeModelCommand({
+            modelId,
+            contentType: 'application/json',
+            accept: 'application/json',
+            body: JSON.stringify(this.buildRequestBody(input)),
+        }));
+        const payload = JSON.parse(this.readUtf8Body(response.body));
+        const usage = payload.usage && typeof payload.usage === 'object'
+            ? payload.usage
+            : null;
+        const inputTokens = this.readNumber(usage?.input_tokens);
+        const outputTokens = this.readNumber(usage?.output_tokens);
+        return {
+            text: this.extractText(payload),
+            provider: 'bedrock-anthropic',
+            modelId: String(payload.model || modelId),
+            ...(payload.stop_reason ? { stopReason: String(payload.stop_reason) } : {}),
+            ...(usage ? {
+                usage: {
+                    inputTokens,
+                    outputTokens,
+                    totalTokens: this.readNumber(usage.total_tokens) ?? (inputTokens !== undefined && outputTokens !== undefined
+                        ? inputTokens + outputTokens
+                        : undefined),
+                },
+            } : {}),
+            latencyMs: Date.now() - startedAt,
+        };
+    }
+    resolveModelId(input) {
+        const modelKey = String(input.modelKey || '').trim();
+        if (!modelKey)
+            throw new Error('No Taskforce HQ Anthropic Messages model selected.');
+        const modelId = this.modelKeyIds[modelKey];
+        if (!modelId)
+            throw new Error('No Taskforce HQ Anthropic Messages model configured for the selected model.');
+        return modelId;
+    }
+    buildRequestBody(input) {
+        return {
+            anthropic_version: 'bedrock-2023-05-31',
+            max_tokens: input.maxTokens ?? 512,
+            ...(input.system ? { system: input.system } : {}),
+            messages: input.messages.map((message) => ({
+                role: message.role,
+                content: message.content,
+            })),
+            ...(input.temperature !== undefined ? { temperature: input.temperature } : {}),
+        };
+    }
+    readUtf8Body(body) {
+        if (!body)
+            return '{}';
+        if (typeof body === 'string')
+            return body;
+        if (ArrayBuffer.isView(body))
+            return new TextDecoder().decode(body);
+        if (typeof body.transformToString === 'function') {
+            return body.transformToString();
+        }
+        return String(body);
+    }
+    extractText(payload) {
+        const content = Array.isArray(payload.content) ? payload.content : [];
+        return content
+            .map((block) => typeof block?.text === 'string' ? block.text : undefined)
+            .filter((text) => Boolean(text && text.length > 0))
+            .join('\n\n');
+    }
+    readNumber(value) {
+        return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+    }
+}

package/dist/services/bedrockMantleModelGateway.d.ts

@@ -0,0 +1,43 @@
+import type { ModelGateway, ModelGatewayGenerateInput, ModelGatewayGenerateResult } from './modelGateway.js';
+type BedrockMantleResponsesClient = {
+    responses: {
+        create(input: {
+            model: string;
+            input: string;
+            instructions?: string;
+            max_output_tokens?: number;
+            temperature?: number;
+        }): Promise<{
+            output_text?: string;
+            output?: unknown[];
+            model?: string;
+            status?: string;
+            incomplete_details?: {
+                reason?: string;
+            } | null;
+            usage?: {
+                input_tokens?: number;
+                output_tokens?: number;
+                total_tokens?: number;
+            };
+        }>;
+    };
+};
+export type BedrockMantleModelKeyIdMap = Partial<Record<string, string>>;
+export interface BedrockMantleModelGatewayOptions {
+    client?: BedrockMantleResponsesClient;
+    region?: string;
+    modelKeyIds?: BedrockMantleModelKeyIdMap;
+}
+export declare const DEFAULT_BEDROCK_MANTLE_MODEL_KEY_IDS: BedrockMantleModelKeyIdMap;
+export declare class BedrockMantleModelGateway implements ModelGateway {
+    private readonly client;
+    private readonly modelKeyIds;
+    constructor(options?: BedrockMantleModelGatewayOptions);
+    generate(input: ModelGatewayGenerateInput): Promise<ModelGatewayGenerateResult>;
+    private resolveModelId;
+    private formatMessages;
+    private extractText;
+    private extractTextFields;
+}
+export {};

package/dist/services/bedrockMantleModelGateway.js

@@ -0,0 +1,81 @@
+import OpenAI from 'openai';
+import { bedrock } from 'openai/providers/bedrock/aws';
+import { TASKFORCE_AGENT_MODEL_OPTIONS } from '../shared/taskforceAgentModels.js';
+export const DEFAULT_BEDROCK_MANTLE_MODEL_KEY_IDS = {
+    ...Object.fromEntries(TASKFORCE_AGENT_MODEL_OPTIONS
+        .filter((model) => model.runtime === 'bedrock-mantle')
+        .map((model) => [model.key, model.runtimeModelId])),
+};
+export class BedrockMantleModelGateway {
+    client;
+    modelKeyIds;
+    constructor(options = {}) {
+        const region = options.region ?? process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-west-2';
+        this.client = options.client ?? new OpenAI({
+            provider: bedrock({ region }),
+        });
+        this.modelKeyIds = {
+            ...DEFAULT_BEDROCK_MANTLE_MODEL_KEY_IDS,
+            ...(options.modelKeyIds ?? {}),
+        };
+    }
+    async generate(input) {
+        const modelId = this.resolveModelId(input);
+        const startedAt = Date.now();
+        const response = await this.client.responses.create({
+            model: modelId,
+            input: this.formatMessages(input),
+            ...(input.system ? { instructions: input.system } : {}),
+            ...(input.maxTokens !== undefined ? { max_output_tokens: input.maxTokens } : {}),
+            ...(input.temperature !== undefined ? { temperature: input.temperature } : {}),
+        });
+        return {
+            text: this.extractText(response),
+            provider: 'bedrock-mantle',
+            modelId: response.model || modelId,
+            stopReason: response.incomplete_details?.reason || response.status,
+            ...(response.usage ? {
+                usage: {
+                    inputTokens: response.usage.input_tokens,
+                    outputTokens: response.usage.output_tokens,
+                    totalTokens: response.usage.total_tokens,
+                },
+            } : {}),
+            latencyMs: Date.now() - startedAt,
+        };
+    }
+    resolveModelId(input) {
+        const modelKey = String(input.modelKey || '').trim();
+        if (!modelKey)
+            throw new Error('No Taskforce HQ Mantle model selected.');
+        const modelId = this.modelKeyIds[modelKey];
+        if (!modelId)
+            throw new Error('No Taskforce HQ Mantle model configured for the selected model.');
+        return modelId;
+    }
+    formatMessages(input) {
+        return input.messages
+            .map((message) => `${message.role === 'assistant' ? 'Assistant' : 'User'}: ${message.content}`)
+            .join('\n\n');
+    }
+    extractText(response) {
+        const directText = String(response.output_text || '').trim();
+        if (directText)
+            return directText;
+        return (response.output || [])
+            .flatMap((item) => this.extractTextFields(item))
+            .filter((text) => Boolean(text && text.trim()))
+            .join('\n')
+            .trim();
+    }
+    extractTextFields(value) {
+        if (!value || typeof value !== 'object')
+            return [];
+        const record = value;
+        const content = Array.isArray(record.content) ? record.content : [];
+        return [
+            typeof record.text === 'string' ? record.text : undefined,
+            ...content.flatMap((item) => this.extractTextFields(item)),
+        ];
+    }
+}