@taskforcehq/taskforce 0.3.306 → 0.3.307

package/dist/mcp/taskAttachmentTypes.d.ts

@@ -6,7 +6,7 @@ export type TaskAttachmentRecord = {
     displayName?: string;
     originalFilename?: string;
     timestamp?: string;
-    assetId?: string;
+    assetId?: string | null;
     referenceNumber?: number | null;
     referenceLabel?: string | null;
     taskId?: string | null;

package/dist/mcp/taskPlanningRegistrar.js

@@ -87,6 +87,18 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
                 description: stringProperty('Optional initiative description.'),
                 ownerId: stringProperty(`${context.assigneeHint} Call list_assignees to inspect the current eligible IDs.`),
                 order: numberProperty('Optional sort order among initiatives.'),
+                attachments: arrayProperty('Optional attachment descriptors to store on the initiative. Prefer save_initiative_attachment for generated content or files.', {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string' },
+                        fsPath: { type: 'string' },
+                        caption: { type: 'string' },
+                        displayName: { type: 'string' },
+                        originalFilename: { type: 'string' },
+                        assetId: { type: 'string' },
+                    },
+                    required: ['path'],
+                }),
             },
             required: ['title'],
         },
@@ -100,6 +112,18 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
                 description: stringProperty('Updated initiative description.'),
                 ownerId: stringProperty(`${context.assigneeHint} Call list_assignees to inspect the current eligible IDs.`),
                 order: numberProperty('Optional sort order among initiatives.'),
+                attachments: arrayProperty('Replacement attachment descriptors for the initiative. Prefer save_initiative_attachment and delete_initiative_attachment for generated content or files.', {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string' },
+                        fsPath: { type: 'string' },
+                        caption: { type: 'string' },
+                        displayName: { type: 'string' },
+                        originalFilename: { type: 'string' },
+                        assetId: { type: 'string' },
+                    },
+                    required: ['path'],
+                }),
             },
             required: ['id'],
         },
@@ -144,6 +168,18 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
                 ownerId: stringProperty(`${context.assigneeHint} Call list_assignees to inspect the current eligible IDs.`),
                 initiativeId: stringProperty('Optional initiative ID or initiative reference such as IN-123.'),
                 order: numberProperty('Optional sort order among workstreams.'),
+                attachments: arrayProperty('Optional attachment descriptors to store on the workstream. Prefer save_workstream_attachment for generated content or files.', {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string' },
+                        fsPath: { type: 'string' },
+                        caption: { type: 'string' },
+                        displayName: { type: 'string' },
+                        originalFilename: { type: 'string' },
+                        assetId: { type: 'string' },
+                    },
+                    required: ['path'],
+                }),
             },
             required: ['title'],
         },
@@ -158,6 +194,18 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
                 ownerId: stringProperty(`${context.assigneeHint} Call list_assignees to inspect the current eligible IDs.`),
                 initiativeId: stringProperty('Optional initiative ID or initiative reference such as IN-123. Pass an empty string to unlink.'),
                 order: numberProperty('Optional sort order among workstreams.'),
+                attachments: arrayProperty('Replacement attachment descriptors for the workstream. Prefer save_workstream_attachment and delete_workstream_attachment for generated content or files.', {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string' },
+                        fsPath: { type: 'string' },
+                        caption: { type: 'string' },
+                        displayName: { type: 'string' },
+                        originalFilename: { type: 'string' },
+                        assetId: { type: 'string' },
+                    },
+                    required: ['path'],
+                }),
             },
             required: ['id'],
         },

package/dist/mcp/toolRegistry.d.ts

@@ -185,6 +185,62 @@ export declare const MCP_TOOL_REGISTRY: Readonly<{
         };
         readonly mutating: false;
     };
+    readonly get_workstream_attachments: {
+        readonly permission: {
+            readonly kind: "scope";
+            readonly scope: "tasks:read";
+        };
+        readonly mutating: false;
+    };
+    readonly read_workstream_attachment: {
+        readonly permission: {
+            readonly kind: "scope";
+            readonly scope: "tasks:read";
+        };
+        readonly mutating: false;
+    };
+    readonly save_workstream_attachment: {
+        readonly permission: {
+            readonly kind: "scope";
+            readonly scope: "tasks:write";
+        };
+        readonly mutating: true;
+    };
+    readonly delete_workstream_attachment: {
+        readonly permission: {
+            readonly kind: "scope";
+            readonly scope: "tasks:write";
+        };
+        readonly mutating: true;
+    };
+    readonly get_initiative_attachments: {
+        readonly permission: {
+            readonly kind: "scope";
+            readonly scope: "tasks:read";
+        };
+        readonly mutating: false;
+    };
+    readonly read_initiative_attachment: {
+        readonly permission: {
+            readonly kind: "scope";
+            readonly scope: "tasks:read";
+        };
+        readonly mutating: false;
+    };
+    readonly save_initiative_attachment: {
+        readonly permission: {
+            readonly kind: "scope";
+            readonly scope: "tasks:write";
+        };
+        readonly mutating: true;
+    };
+    readonly delete_initiative_attachment: {
+        readonly permission: {
+            readonly kind: "scope";
+            readonly scope: "tasks:write";
+        };
+        readonly mutating: true;
+    };
     readonly search_images: {
         readonly permission: {
             readonly kind: "scope";

package/dist/mcp/toolRegistry.js

@@ -26,6 +26,14 @@ export const MCP_TOOL_REGISTRY = Object.freeze({
     replace_task_checklist: { permission: { kind: 'scope', scope: 'tasks:write' }, mutating: true },
     get_task_attachments: { permission: { kind: 'scope', scope: 'tasks:read' }, mutating: false },
     read_task_attachment: { permission: { kind: 'scope', scope: 'tasks:read' }, mutating: false },
+    get_workstream_attachments: { permission: { kind: 'scope', scope: 'tasks:read' }, mutating: false },
+    read_workstream_attachment: { permission: { kind: 'scope', scope: 'tasks:read' }, mutating: false },
+    save_workstream_attachment: { permission: { kind: 'scope', scope: 'tasks:write' }, mutating: true },
+    delete_workstream_attachment: { permission: { kind: 'scope', scope: 'tasks:write' }, mutating: true },
+    get_initiative_attachments: { permission: { kind: 'scope', scope: 'tasks:read' }, mutating: false },
+    read_initiative_attachment: { permission: { kind: 'scope', scope: 'tasks:read' }, mutating: false },
+    save_initiative_attachment: { permission: { kind: 'scope', scope: 'tasks:write' }, mutating: true },
+    delete_initiative_attachment: { permission: { kind: 'scope', scope: 'tasks:write' }, mutating: true },
     search_images: { permission: { kind: 'scope', scope: 'tasks:read' }, mutating: false },
     get_image: { permission: { kind: 'scope', scope: 'tasks:read' }, mutating: false },
     search_documents: { permission: { kind: 'scope', scope: 'tasks:read' }, mutating: false },

package/dist/mcp/toolRegistry.test.js

@@ -11,6 +11,8 @@ describe('MCP tool registry', () => {
         expect(MCP_CLOUD_TOOL_SCOPE_REQUIREMENTS.search_documents).toBe('tasks:read');
         expect(MCP_CLOUD_TOOL_SCOPE_REQUIREMENTS.read_task_attachment).toBe('tasks:read');
         expect(MCP_CLOUD_TOOL_SCOPE_REQUIREMENTS.get_task_attachments).toBe('tasks:read');
+        expect(MCP_CLOUD_TOOL_SCOPE_REQUIREMENTS.read_workstream_attachment).toBe('tasks:read');
+        expect(MCP_CLOUD_TOOL_SCOPE_REQUIREMENTS.get_initiative_attachments).toBe('tasks:read');
         expect(MCP_CLOUD_TOOL_SCOPE_REQUIREMENTS.export_resources).toBeUndefined();
     });
     it('derives mutating tool names from the shared registry', () => {
@@ -20,6 +22,8 @@ describe('MCP tool registry', () => {
         expect(MCP_WRITE_TOOL_NAMES).toEqual(expected);
         expect(MCP_WRITE_TOOL_NAMES.has('read_task_attachment')).toBe(false);
         expect(MCP_WRITE_TOOL_NAMES.has('save_task_attachment')).toBe(true);
+        expect(MCP_WRITE_TOOL_NAMES.has('save_workstream_attachment')).toBe(true);
+        expect(MCP_WRITE_TOOL_NAMES.has('delete_initiative_attachment')).toBe(true);
         expect(MCP_WRITE_TOOL_NAMES.has('finish_task')).toBe(true);
         expect(MCP_WRITE_TOOL_NAMES.has('review_document')).toBe(true);
     });

package/dist/migrations/taskSchemaMigrations.js

@@ -198,6 +198,25 @@ export function ensureWorkspaceSchema(db) {
             FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
         );
 
+        CREATE TABLE IF NOT EXISTS task_attachment_upload_drafts (
+            draft_id TEXT PRIMARY KEY,
+            tenant_id TEXT NOT NULL DEFAULT 'default',
+            workspace_id TEXT NOT NULL,
+            task_id TEXT NOT NULL,
+            actor_ref TEXT NOT NULL,
+            storage_key TEXT NOT NULL,
+            mime_type TEXT NOT NULL,
+            original_filename TEXT NOT NULL,
+            size_bytes INTEGER NOT NULL DEFAULT 0,
+            storage_provider TEXT NOT NULL DEFAULT 'local',
+            consumed_at TEXT,
+            discarded_at TEXT,
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL,
+            FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE,
+            FOREIGN KEY (workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE
+        );
+
         CREATE TABLE IF NOT EXISTS auth_tokens (
             id TEXT PRIMARY KEY,
             tenant_id TEXT NOT NULL DEFAULT 'default',
@@ -388,6 +407,8 @@ export function ensureWorkspaceSchema(db) {
         CREATE INDEX IF NOT EXISTS idx_auth_tokens_user_purpose ON auth_tokens(user_id, purpose);
         CREATE INDEX IF NOT EXISTS idx_auth_tokens_workspace_purpose ON auth_tokens(workspace_id, purpose);
         CREATE INDEX IF NOT EXISTS idx_auth_tokens_expires ON auth_tokens(expires_at);
+        CREATE INDEX IF NOT EXISTS idx_task_attachment_upload_drafts_workspace_task ON task_attachment_upload_drafts(workspace_id, task_id);
+        CREATE INDEX IF NOT EXISTS idx_task_attachment_upload_drafts_actor_created ON task_attachment_upload_drafts(actor_ref, created_at);
         CREATE UNIQUE INDEX IF NOT EXISTS idx_mcp_access_tokens_prefix ON mcp_access_tokens(token_prefix);
         CREATE INDEX IF NOT EXISTS idx_mcp_access_tokens_workspace_user ON mcp_access_tokens(workspace_id, user_id);
         CREATE INDEX IF NOT EXISTS idx_mcp_access_tokens_status ON mcp_access_tokens(status);

package/dist/server/aiProfileAvatarAssets.d.ts

@@ -0,0 +1,49 @@
+import type { TaskforceCore } from '../core/Taskforce.js';
+import type { ObjectStorageClient } from '../storage/objectStorageClient.js';
+import type { WorkspaceAssetStore } from '../storage/workspaceAssetStore.js';
+type AiAvatarSlot = 'display' | 'source';
+export interface AiProfileAvatarPayload {
+    buffer: Buffer;
+    mimeType: string;
+    originalName?: string | null;
+}
+export interface AiProfileAvatarAssetDeps {
+    core: TaskforceCore;
+    workspaceAssetStore: WorkspaceAssetStore | null;
+    getObjectStorageClient: () => ObjectStorageClient | null;
+    ensureWithinDir: (candidatePath: string, rootDir: string) => string | null;
+    markAssetDeleted: (pathValue: string) => unknown;
+    appendStorageTelemetry: (event: string, payload?: {
+        path?: string;
+        status?: string;
+        provider?: string;
+    }) => void;
+}
+export interface SaveAiProfileAvatarInput {
+    workspaceId: string;
+    profileId: string;
+    display: AiProfileAvatarPayload;
+    source?: AiProfileAvatarPayload | null;
+    actorId?: string | null;
+}
+export declare function buildAiProfileAvatarStorageKey(input: {
+    workspaceId: string;
+    profileId: string;
+    slot: AiAvatarSlot;
+    mimeType: string;
+}): string;
+export declare function storageKeyFromContextUrl(url: unknown): string | null;
+export declare function saveAiProfileAvatarAssets(deps: AiProfileAvatarAssetDeps, input: SaveAiProfileAvatarInput): Promise<{
+    profile: import("../core/Taskforce.js").AiProfileRecord;
+    displayAsset: import("../storage/workspaceAssetStore.js").WorkspaceAssetEntry;
+    sourceAsset: import("../storage/workspaceAssetStore.js").WorkspaceAssetEntry;
+    displayStorageKey: string;
+    sourceStorageKey: string;
+}>;
+export declare function clearAiProfileAvatarAssets(deps: AiProfileAvatarAssetDeps, input: {
+    workspaceId: string;
+    profileId: string;
+}): Promise<{
+    profile: import("../core/Taskforce.js").AiProfileRecord;
+}>;
+export {};

package/dist/server/aiProfileAvatarAssets.js

@@ -0,0 +1,319 @@
+import { createHash } from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+import { normalizeTaskDataRelativePath } from '../storage/objectStorageClient.js';
+const SUPPORTED_IMAGE_MIME_TYPES = new Set([
+    'image/gif',
+    'image/jpeg',
+    'image/png',
+    'image/webp',
+]);
+const AVATAR_MAX_BYTES = 5 * 1024 * 1024;
+function normalizeId(value) {
+    return String(value || '').trim();
+}
+function sanitizeStorageSegment(value, fallback) {
+    const normalized = normalizeId(value)
+        .replace(/[^a-zA-Z0-9._-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return normalized || fallback;
+}
+function normalizeImageMimeType(value) {
+    return normalizeId(value).toLowerCase();
+}
+function extensionForMimeType(mimeType) {
+    if (mimeType === 'image/gif')
+        return 'gif';
+    if (mimeType === 'image/jpeg')
+        return 'jpg';
+    if (mimeType === 'image/png')
+        return 'png';
+    return 'webp';
+}
+function stableAssetId(workspaceId, profileId, slot) {
+    const digest = createHash('sha256')
+        .update(`${workspaceId}:${profileId}:${slot}`)
+        .digest('hex')
+        .slice(0, 32);
+    return `asset-${digest}`;
+}
+export function buildAiProfileAvatarStorageKey(input) {
+    const workspaceId = sanitizeStorageSegment(input.workspaceId, 'default');
+    const profileId = sanitizeStorageSegment(input.profileId, 'ai-profile');
+    const ext = extensionForMimeType(input.mimeType);
+    return `workspaces/${workspaceId}/assets/images/ai-profiles/${profileId}/avatar/${input.slot}.${ext}`;
+}
+function contextUrlForStorageKey(storageKey) {
+    return `/api/taskforce/context/${encodeURIComponent(storageKey)}`;
+}
+export function storageKeyFromContextUrl(url) {
+    const raw = normalizeId(url);
+    if (!raw)
+        return null;
+    const contextPrefix = '/api/taskforce/context/';
+    if (!raw.startsWith(contextPrefix))
+        return null;
+    const encodedPath = raw.slice(contextPrefix.length).split('?')[0] || '';
+    try {
+        return normalizeTaskDataRelativePath(decodeURIComponent(encodedPath));
+    }
+    catch {
+        return null;
+    }
+}
+function validatePayload(payload, label) {
+    const mimeType = normalizeImageMimeType(payload.mimeType);
+    if (!SUPPORTED_IMAGE_MIME_TYPES.has(mimeType)) {
+        throw new Error(`${label} must be a PNG, JPEG, WebP, or GIF image.`);
+    }
+    if (!Buffer.isBuffer(payload.buffer) || payload.buffer.length === 0) {
+        throw new Error(`${label} is empty.`);
+    }
+    if (payload.buffer.length > AVATAR_MAX_BYTES) {
+        throw new Error(`${label} must be 5 MB or smaller.`);
+    }
+    return mimeType;
+}
+function storageKeyBelongsToAiProfileAvatar(workspaceId, profileId, storageKey) {
+    const workspaceIdSafe = sanitizeStorageSegment(workspaceId, 'default');
+    const profileIdSafe = sanitizeStorageSegment(profileId, 'ai-profile');
+    return storageKey.startsWith(`workspaces/${workspaceIdSafe}/assets/images/ai-profiles/${profileIdSafe}/avatar/`);
+}
+async function writeAvatarObject(deps, storageKey, payload, provider) {
+    if (provider === 'r2') {
+        const objectStorageClient = deps.getObjectStorageClient();
+        if (!objectStorageClient)
+            throw new Error('Object storage is not configured.');
+        await objectStorageClient.putObject(storageKey, payload.buffer, payload.mimeType);
+        return;
+    }
+    const { basePath } = deps.core.getPaths();
+    const destination = deps.ensureWithinDir(path.join(basePath, storageKey), basePath);
+    if (!destination)
+        throw new Error('Invalid AI profile avatar storage path.');
+    fs.mkdirSync(path.dirname(destination), { recursive: true });
+    fs.writeFileSync(destination, payload.buffer);
+}
+async function deleteAvatarObject(deps, storageKey, provider) {
+    try {
+        deps.markAssetDeleted(storageKey);
+    }
+    catch {
+        // Best-effort legacy asset index cleanup should not make the canonical
+        // workspace asset/profile update fail after the new slots are written.
+    }
+    if (provider === 'r2') {
+        const objectStorageClient = deps.getObjectStorageClient();
+        if (objectStorageClient) {
+            await objectStorageClient.deleteObject(storageKey).catch(() => false);
+        }
+        return;
+    }
+    const { basePath } = deps.core.getPaths();
+    const destination = deps.ensureWithinDir(path.join(basePath, storageKey), basePath);
+    if (destination && fs.existsSync(destination)) {
+        fs.rmSync(destination, { force: true });
+    }
+}
+function upsertAvatarAsset(input) {
+    if (!input.deps.workspaceAssetStore) {
+        throw new Error('Workspace asset storage is required for AI profile avatars.');
+    }
+    const contentSha256 = createHash('sha256').update(input.payload.buffer).digest('hex');
+    const existing = input.deps.workspaceAssetStore.getByStorageKey(input.storageKey, input.workspaceId);
+    return input.deps.workspaceAssetStore.upsertAsset({
+        assetId: existing?.assetId || stableAssetId(input.workspaceId, input.profileId, input.slot),
+        workspaceId: input.workspaceId,
+        kind: 'image',
+        logicalName: `AI profile avatar ${input.slot}`,
+        originalFilename: normalizeId(input.payload.originalName) || `${input.slot}.${extensionForMimeType(input.payload.mimeType)}`,
+        mimeType: input.payload.mimeType,
+        storageProvider: input.provider,
+        storageKey: input.storageKey,
+        contentSha256,
+        sizeBytes: input.payload.buffer.length,
+        documentId: null,
+        version: null,
+        isLatest: true,
+        scanStatus: 'clean',
+        scanEngine: null,
+        scanDetails: null,
+        createdByUserId: existing?.createdByUserId || normalizeId(input.actorId) || null,
+        createdAt: existing?.createdAt || input.nowIso,
+        updatedAt: input.nowIso,
+        deletedAt: null,
+        purgeAfter: null,
+    });
+}
+async function cleanupAiProfileAvatarAssets(input) {
+    const keep = new Set(Array.from(input.keepStorageKeys || []).filter(Boolean));
+    const candidates = new Map();
+    for (const storageKey of input.explicitStorageKeys || []) {
+        const normalized = normalizeTaskDataRelativePath(normalizeId(storageKey));
+        if (!normalized || keep.has(normalized))
+            continue;
+        if (storageKeyBelongsToAiProfileAvatar(input.workspaceId, input.profileId, normalized)) {
+            candidates.set(normalized, input.providerFallback);
+        }
+    }
+    if (input.deps.workspaceAssetStore) {
+        const assets = input.deps.workspaceAssetStore.listAllByWorkspace(input.workspaceId, {
+            includeDeleted: false,
+            kind: 'image',
+        });
+        for (const asset of assets) {
+            if (!storageKeyBelongsToAiProfileAvatar(input.workspaceId, input.profileId, asset.storageKey))
+                continue;
+            if (keep.has(asset.storageKey))
+                continue;
+            candidates.set(asset.storageKey, asset.storageProvider === 'r2' ? 'r2' : 'local');
+        }
+    }
+    for (const [storageKey, provider] of candidates) {
+        try {
+            const asset = input.deps.workspaceAssetStore?.getByStorageKey(storageKey, input.workspaceId);
+            if (asset && !asset.deletedAt) {
+                input.deps.workspaceAssetStore?.markDeleted(asset.assetId, input.workspaceId);
+            }
+        }
+        catch {
+            input.deps.appendStorageTelemetry('ai_avatar.cleanup', {
+                path: storageKey,
+                provider,
+                status: 'metadata-delete-failed',
+            });
+        }
+        try {
+            await deleteAvatarObject(input.deps, storageKey, provider);
+            input.deps.appendStorageTelemetry('ai_avatar.cleanup', {
+                path: storageKey,
+                provider,
+                status: 'deleted',
+            });
+        }
+        catch {
+            input.deps.appendStorageTelemetry('ai_avatar.cleanup', {
+                path: storageKey,
+                provider,
+                status: 'object-delete-failed',
+            });
+        }
+    }
+}
+export async function saveAiProfileAvatarAssets(deps, input) {
+    const workspaceId = normalizeId(input.workspaceId);
+    const profileId = normalizeId(input.profileId);
+    if (!workspaceId)
+        throw new Error('workspaceId is required.');
+    if (!profileId)
+        throw new Error('profileId is required.');
+    const existingProfile = deps.core.listAiProfiles(workspaceId)
+        .find((profile) => profile.id === profileId);
+    if (!existingProfile)
+        throw new Error(`Profile ${profileId} not found.`);
+    const displayMimeType = validatePayload(input.display, 'Display avatar');
+    const sourcePayload = input.source || input.display;
+    const sourceMimeType = validatePayload(sourcePayload, 'Source avatar');
+    const displayPayload = { ...input.display, mimeType: displayMimeType };
+    const normalizedSourcePayload = { ...sourcePayload, mimeType: sourceMimeType };
+    const displayStorageKey = buildAiProfileAvatarStorageKey({
+        workspaceId,
+        profileId,
+        slot: 'display',
+        mimeType: displayMimeType,
+    });
+    const sourceStorageKey = buildAiProfileAvatarStorageKey({
+        workspaceId,
+        profileId,
+        slot: 'source',
+        mimeType: sourceMimeType,
+    });
+    const objectStorageClient = deps.getObjectStorageClient();
+    const provider = objectStorageClient ? 'r2' : 'local';
+    const nowIso = new Date().toISOString();
+    await writeAvatarObject(deps, displayStorageKey, displayPayload, provider);
+    await writeAvatarObject(deps, sourceStorageKey, normalizedSourcePayload, provider);
+    const displayAsset = upsertAvatarAsset({
+        deps,
+        workspaceId,
+        profileId,
+        slot: 'display',
+        storageKey: displayStorageKey,
+        payload: displayPayload,
+        provider,
+        actorId: input.actorId,
+        nowIso,
+    });
+    const sourceAsset = upsertAvatarAsset({
+        deps,
+        workspaceId,
+        profileId,
+        slot: 'source',
+        storageKey: sourceStorageKey,
+        payload: normalizedSourcePayload,
+        provider,
+        actorId: input.actorId,
+        nowIso,
+    });
+    deps.core.notifyDocumentMetadataMutation(workspaceId, [displayStorageKey, sourceStorageKey], 'upsert');
+    deps.appendStorageTelemetry('ai_avatar.upload', {
+        path: displayStorageKey,
+        provider,
+        status: 'stored',
+    });
+    const profile = deps.core.updateAiProfileAvatar({
+        workspaceId,
+        profileId,
+        avatarUrl: contextUrlForStorageKey(displayStorageKey),
+        avatarSourceUrl: contextUrlForStorageKey(sourceStorageKey),
+    });
+    await cleanupAiProfileAvatarAssets({
+        deps,
+        workspaceId,
+        profileId,
+        keepStorageKeys: [displayStorageKey, sourceStorageKey],
+        explicitStorageKeys: [
+            storageKeyFromContextUrl(existingProfile.avatarUrl),
+            storageKeyFromContextUrl(existingProfile.avatarSourceUrl),
+        ],
+        providerFallback: provider,
+    });
+    return {
+        profile,
+        displayAsset,
+        sourceAsset,
+        displayStorageKey,
+        sourceStorageKey,
+    };
+}
+export async function clearAiProfileAvatarAssets(deps, input) {
+    const workspaceId = normalizeId(input.workspaceId);
+    const profileId = normalizeId(input.profileId);
+    if (!workspaceId)
+        throw new Error('workspaceId is required.');
+    if (!profileId)
+        throw new Error('profileId is required.');
+    const existingProfile = deps.core.listAiProfiles(workspaceId)
+        .find((profile) => profile.id === profileId);
+    const objectStorageClient = deps.getObjectStorageClient();
+    const provider = objectStorageClient ? 'r2' : 'local';
+    const profile = deps.core.updateAiProfileAvatar({
+        workspaceId,
+        profileId,
+        avatarUrl: null,
+        avatarSourceUrl: null,
+    });
+    await cleanupAiProfileAvatarAssets({
+        deps,
+        workspaceId,
+        profileId,
+        keepStorageKeys: [],
+        explicitStorageKeys: [
+            storageKeyFromContextUrl(existingProfile?.avatarUrl),
+            storageKeyFromContextUrl(existingProfile?.avatarSourceUrl),
+        ],
+        providerFallback: provider,
+    });
+    return { profile };
+}

package/dist/server/aiProfileAvatarAssets.test.d.ts

@@ -0,0 +1 @@
+export {};