@taskforcehq/taskforce 0.3.326 → 0.3.328

package/dist/service/localServiceClientLifecycle.js

@@ -0,0 +1,189 @@
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import { applyLocalServiceCloudTarget, localServiceCloudTargetsEqual, parseLocalServiceCloudTarget, resolveLocalServiceCloudTarget, } from '../config/localServiceCloudTarget.js';
+import { inspectLocalServiceDescriptor, } from '../server/localServiceLease.js';
+import { resolveLocalDatabaseIdentity } from '../server/localDatabaseIdentity.js';
+export const LOCAL_SERVICE_PROTOCOL_VERSION = '1';
+export const LOCAL_SERVICE_API_BASE_PATH = '/api/taskforce/local-service/v1';
+export const LOCAL_SERVICE_STARTUP_TIMEOUT_MS = 15_000;
+export const LOCAL_SERVICE_STARTUP_POLL_MS = 100;
+const LOCAL_MCP_CLIENT_ENV_KEYS = [
+    'TASKFORCE_MCP_CLIENT_ID',
+    'TASKFORCE_MCP_CONNECTION_ID',
+    'TASKFORCE_MCP_TOOL_PROFILE',
+    'TASKFORCE_AI_PROFILE_TOKEN',
+    'TASKFORCE_AI_NAME',
+    'TASKFORCE_AI_ICON',
+    'TASKFORCE_AI_COLOR',
+    'TASKFORCE_AI_DESCRIPTION',
+    'TASKFORCE_AI_ROLE',
+    'TASKFORCE_AI_PROVIDER',
+    'TASKFORCE_AI_MODEL',
+    'TASKFORCE_AI_SURFACE_TYPE',
+    'TASKFORCE_AI_SEAT_SCOPE',
+];
+export function resolveLocalServiceLeaseInput(projectRoot, env) {
+    const provider = env.TASKFORCE_DB_PROVIDER === 'postgres' ? 'postgres' : 'sqlite';
+    return {
+        projectRoot,
+        databaseIdentity: resolveLocalDatabaseIdentity(projectRoot, provider, env),
+        databaseIdentityKind: provider === 'sqlite' ? 'path' : 'opaque',
+    };
+}
+export function spawnDetachedLocalService(executablePath, args, env) {
+    const child = spawn(executablePath, [...args], {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+        env,
+    });
+    child.unref();
+}
+function buildLocalServiceProcessEnv(env, cloudTarget) {
+    const serviceEnv = { ...env };
+    for (const key of LOCAL_MCP_CLIENT_ENV_KEYS)
+        delete serviceEnv[key];
+    applyLocalServiceCloudTarget(serviceEnv, cloudTarget);
+    return serviceEnv;
+}
+export async function waitForLocalServiceDescriptor(input, expected, options = {}) {
+    const inspectDescriptor = options.inspectDescriptor || inspectLocalServiceDescriptor;
+    const sleep = options.sleep || ((delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs)));
+    const nowMs = options.nowMs || Date.now;
+    const deadline = nowMs() + (options.timeoutMs ?? LOCAL_SERVICE_STARTUP_TIMEOUT_MS);
+    let inspection = await inspectDescriptor(input);
+    while (inspection.status !== expected && nowMs() < deadline) {
+        await sleep(LOCAL_SERVICE_STARTUP_POLL_MS);
+        inspection = await inspectDescriptor(input);
+    }
+    return inspection;
+}
+async function validateLocalServiceReadiness(descriptor, fetchFn) {
+    let response;
+    try {
+        response = await fetchFn(`${descriptor.endpoint}${LOCAL_SERVICE_API_BASE_PATH}/readiness`, {
+            redirect: 'error',
+            signal: AbortSignal.timeout(LOCAL_SERVICE_STARTUP_TIMEOUT_MS),
+        });
+    }
+    catch (error) {
+        throw new Error(`Taskforce shared local service readiness failed: ${String(error?.message || error)}`);
+    }
+    if (!response.ok) {
+        throw new Error(`Taskforce shared local service readiness failed (${response.status}).`);
+    }
+    let readiness;
+    try {
+        readiness = await response.json();
+    }
+    catch {
+        throw new Error('Taskforce shared local service readiness returned invalid JSON.');
+    }
+    const readinessHasCloudTarget = Object.prototype.hasOwnProperty.call(readiness, 'cloudTarget');
+    const readinessCloudTarget = readinessHasCloudTarget
+        ? parseLocalServiceCloudTarget(readiness.cloudTarget)
+        : null;
+    const descriptorCloudTarget = descriptor.cloudTarget || null;
+    const cloudTargetsMatch = descriptorCloudTarget || readinessCloudTarget
+        ? localServiceCloudTargetsEqual(descriptorCloudTarget, readinessCloudTarget)
+        : true;
+    if (readiness.ready !== true
+        || readiness.protocolVersion !== LOCAL_SERVICE_PROTOCOL_VERSION
+        || readiness.protocolVersion !== descriptor.protocolVersion
+        || readiness.generation !== descriptor.generation
+        || readiness.pid !== descriptor.pid
+        || readiness.endpoint !== descriptor.endpoint
+        || readiness.dataIdentity !== descriptor.ownershipKey
+        || (readinessHasCloudTarget && !readinessCloudTarget)
+        || !cloudTargetsMatch) {
+        throw new Error('Taskforce shared local service readiness does not match its descriptor.');
+    }
+    return descriptorCloudTarget;
+}
+async function requestIdleLocalServiceShutdown(descriptor, fetchFn) {
+    let response;
+    try {
+        response = await fetchFn(`${descriptor.endpoint}${LOCAL_SERVICE_API_BASE_PATH}/shutdown`, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                'x-taskforce-local-service-capability': descriptor.bootstrapCapability,
+            },
+            body: JSON.stringify({
+                intent: 'administrative-stop',
+                mode: 'refuse',
+                pid: descriptor.pid,
+                generation: descriptor.generation,
+            }),
+            redirect: 'error',
+            signal: AbortSignal.timeout(LOCAL_SERVICE_STARTUP_TIMEOUT_MS),
+        });
+    }
+    catch (error) {
+        throw new Error('Taskforce service uses a different cloud target and could not be stopped safely. '
+            + `No replacement was started. ${String(error?.message || error)}`);
+    }
+    if (!response.ok) {
+        const detail = (await response.text()).slice(0, 500);
+        const activeClientHint = response.status === 409
+            ? ' It may have active MCP clients; close them or run `taskforce service stop --drain`, then retry.'
+            : '';
+        throw new Error(`Taskforce service uses a different cloud target and refused safe idle replacement (${response.status}).`
+            + activeClientHint
+            + (detail ? ` ${detail}` : ''));
+    }
+}
+export async function discoverOrStartLocalService(input) {
+    const requestedRoot = path.resolve(input.projectRoot);
+    const projectRoot = fs.existsSync(requestedRoot) ? fs.realpathSync(requestedRoot) : requestedRoot;
+    const leaseInput = resolveLocalServiceLeaseInput(projectRoot, input.env);
+    const inspectDescriptor = input.inspectDescriptor || inspectLocalServiceDescriptor;
+    const fetchFn = input.fetch || fetch;
+    const requestedCloudTarget = resolveLocalServiceCloudTarget(input.env);
+    const current = await inspectDescriptor(leaseInput);
+    if (current.status === 'live' && current.descriptor) {
+        if (current.descriptor.protocolVersion !== LOCAL_SERVICE_PROTOCOL_VERSION) {
+            throw new Error(`Taskforce service protocol ${current.descriptor.protocolVersion} is incompatible with client protocol ${LOCAL_SERVICE_PROTOCOL_VERSION}.`);
+        }
+        const runningCloudTarget = await validateLocalServiceReadiness(current.descriptor, fetchFn);
+        if (localServiceCloudTargetsEqual(runningCloudTarget, requestedCloudTarget)) {
+            return current.descriptor;
+        }
+        await requestIdleLocalServiceShutdown(current.descriptor, fetchFn);
+        const stopped = await waitForLocalServiceDescriptor(leaseInput, 'stale', {
+            inspectDescriptor,
+            sleep: input.sleep,
+            nowMs: input.nowMs,
+        });
+        if (stopped.status !== 'stale') {
+            throw new Error('Taskforce service accepted cloud-target replacement but did not release its owner lease. No replacement was started.');
+        }
+    }
+    if (current.status === 'indeterminate') {
+        throw new Error('Taskforce service state is indeterminate; refusing to start a competing owner.');
+    }
+    (input.spawnDetached || spawnDetachedLocalService)(input.executablePath, [
+        ...(input.execArgv || []),
+        input.cliEntryPath,
+        'service',
+        projectRoot,
+        '--detached-child',
+    ], buildLocalServiceProcessEnv(input.env, requestedCloudTarget));
+    const inspection = await waitForLocalServiceDescriptor(leaseInput, 'live', {
+        inspectDescriptor,
+        sleep: input.sleep,
+        nowMs: input.nowMs,
+    });
+    if (inspection.status !== 'live' || !inspection.descriptor) {
+        throw new Error('Taskforce service did not become ready before the startup deadline.');
+    }
+    if (inspection.descriptor.protocolVersion !== LOCAL_SERVICE_PROTOCOL_VERSION) {
+        throw new Error(`Taskforce service protocol ${inspection.descriptor.protocolVersion} is incompatible with client protocol ${LOCAL_SERVICE_PROTOCOL_VERSION}.`);
+    }
+    const startedCloudTarget = await validateLocalServiceReadiness(inspection.descriptor, fetchFn);
+    if (!localServiceCloudTargetsEqual(startedCloudTarget, requestedCloudTarget)) {
+        throw new Error('Taskforce service started with a different or unverified cloud target; refusing to attach.');
+    }
+    return inspection.descriptor;
+}

package/dist/service/localServiceOpen.d.ts

@@ -0,0 +1,17 @@
+import type { LocalServiceDescriptor } from '../server/localServiceLease.js';
+import { discoverOrStartLocalService } from './localServiceClientLifecycle.js';
+export declare function shouldOpenViaLocalService(env: NodeJS.ProcessEnv): boolean;
+export declare function buildLocalServiceUiUrl(descriptor: LocalServiceDescriptor): string;
+export declare function openTaskforceViaLocalService(input: {
+    projectRoot: string;
+    env: NodeJS.ProcessEnv;
+    executablePath: string;
+    cliEntryPath: string;
+    execArgv?: readonly string[];
+    discover?: typeof discoverOrStartLocalService;
+    openBrowser: (url: string) => void;
+    log?: (message: string) => void;
+}): Promise<{
+    descriptor: LocalServiceDescriptor;
+    url: string;
+}>;

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 {};