@taskforcehq/taskforce 0.3.326 → 0.3.327

package/dist/server/routes/agentRoles.d.ts

@@ -0,0 +1,13 @@
+import type { IncomingMessage, ServerResponse } from 'http';
+import type { TaskforceCore } from '../../core/Taskforce.js';
+import { AgentRoleStore } from '../../storage/agentRoleStore.js';
+import { type RouteHandler } from './primitives.js';
+export interface AgentRolesRouteDependencies {
+    addRoute: (method: string, path: string, handler: RouteHandler) => void;
+    ensureAppAccess: (req: IncomingMessage, res: ServerResponse) => boolean;
+    core?: TaskforceCore;
+    roleStore?: AgentRoleStore;
+    requestWorkspaceId?: (req: IncomingMessage) => string;
+    resolveAuthenticatedMutationUserId?: (req: IncomingMessage) => string | null;
+}
+export declare function registerAgentRolesRoutes(deps: AgentRolesRouteDependencies): void;

package/dist/server/routes/agentRoles.js

@@ -0,0 +1,273 @@
+import { TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY, resolveAppGateAccess, } from '../../runtime/appGates.js';
+import { AgentRoleDefinitionValidationError } from '../../shared/agentRoleDefinition.js';
+import { AgentRoleConflictError, AgentRoleNotFoundError, AgentRoleRetiredError, AgentRoleStore, } from '../../storage/agentRoleStore.js';
+import { parseJsonBody } from './primitives.js';
+import { resolveErrorStatusCode } from './shared.js';
+function writeJson(res, statusCode, payload) {
+    res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(payload));
+}
+function serializeRole(store, workspaceId, role) {
+    return {
+        ...role,
+        revisions: store.listRevisions(workspaceId, role.id).map((revision) => ({
+            revision: revision.revision,
+            contentHash: revision.contentHash,
+            createdByActorId: revision.createdByActorId,
+            createdAt: revision.createdAt,
+        })),
+        usage: {
+            agentCount: store.countAgentUsage(workspaceId, role.id),
+        },
+    };
+}
+function writeError(res, error) {
+    const candidateStatusCode = Number(error?.statusCode);
+    const statusCode = error instanceof AgentRoleDefinitionValidationError
+        || error instanceof AgentRoleConflictError
+        || error instanceof AgentRoleNotFoundError
+        || error instanceof AgentRoleRetiredError
+        ? error.statusCode
+        : Number.isInteger(candidateStatusCode) && candidateStatusCode >= 400 && candidateStatusCode <= 599
+            ? candidateStatusCode
+            : 500;
+    writeJson(res, statusCode, {
+        success: false,
+        error: statusCode >= 500
+            ? 'Unable to process Agent Role request.'
+            : String(error?.message || error || 'Agent Role request failed.'),
+        ...(error?.code
+            ? { code: String(error.code) }
+            : {}),
+        ...(error instanceof AgentRoleDefinitionValidationError
+            ? { issues: error.issues }
+            : {}),
+        ...(error instanceof AgentRoleConflictError
+            ? {
+                currentRevision: error.currentRevision,
+                currentContentHash: error.currentContentHash,
+            }
+            : {}),
+    });
+}
+function queryValue(req, key) {
+    try {
+        return new URL(req.url || '/', 'http://localhost').searchParams.get(key)?.trim() || '';
+    }
+    catch {
+        return '';
+    }
+}
+function resolveWorkspaceId(req, body, requestWorkspaceId) {
+    const authoritativeWorkspaceId = String(requestWorkspaceId?.(req) || '').trim();
+    const requestedWorkspaceId = String(body?.workspaceId || queryValue(req, 'workspaceId') || '').trim();
+    if (authoritativeWorkspaceId
+        && requestedWorkspaceId
+        && requestedWorkspaceId !== authoritativeWorkspaceId) {
+        throw Object.assign(new Error('The requested workspace does not match the authorized workspace.'), { statusCode: 403, code: 'TASKFORCE_AGENT_ROLE_WORKSPACE_FORBIDDEN' });
+    }
+    return authoritativeWorkspaceId || requestedWorkspaceId || 'default';
+}
+export function registerAgentRolesRoutes(deps) {
+    const { addRoute, ensureAppAccess, core, requestWorkspaceId, resolveAuthenticatedMutationUserId, } = deps;
+    let roleStore = deps.roleStore || null;
+    const getStore = () => {
+        if (roleStore)
+            return roleStore;
+        if (!core)
+            throw new Error('Agent Role store is unavailable.');
+        roleStore = new AgentRoleStore(core.getDatabaseAdapter(), core.getTenantId());
+        return roleStore;
+    };
+    const requireWorkspaceActor = (req, res, workspaceId) => {
+        let actorId = '';
+        try {
+            actorId = String(resolveAuthenticatedMutationUserId?.(req) || '').trim();
+        }
+        catch (error) {
+            writeJson(res, resolveErrorStatusCode(error, 401), {
+                success: false,
+                error: String(error?.message || 'Authentication is required.'),
+                code: String(error?.code || 'MUTATION_AUTH_REQUIRED'),
+            });
+            return null;
+        }
+        if (!actorId) {
+            writeJson(res, 401, {
+                success: false,
+                error: 'Authentication is required to manage Roles.',
+                code: 'MUTATION_AUTH_REQUIRED',
+            });
+            return null;
+        }
+        if (core) {
+            const membership = core.listWorkspaceUsers(workspaceId)
+                .find((candidate) => candidate.userId === actorId);
+            if (!membership
+                || membership.disabled === true
+                || String(membership.status || '').toLowerCase() !== 'active') {
+                writeJson(res, 403, {
+                    success: false,
+                    error: 'Workspace membership is required to manage Roles.',
+                    code: 'TASKFORCE_AGENT_ROLE_WORKSPACE_FORBIDDEN',
+                });
+                return null;
+            }
+            if (String(membership.role || '').toLowerCase() === 'read-only'
+                || String(membership.permissionMode || '').toLowerCase() === 'read-only') {
+                writeJson(res, 403, {
+                    success: false,
+                    error: 'Read-only workspace members cannot manage Roles.',
+                    code: 'TASKFORCE_AGENT_ROLE_WRITE_FORBIDDEN',
+                });
+                return null;
+            }
+        }
+        return actorId;
+    };
+    const guard = (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return false;
+        const gate = resolveAppGateAccess(TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY);
+        if (gate.allowed)
+            return true;
+        writeJson(res, 403, {
+            success: false,
+            error: 'Taskforce Agents are unavailable for this workspace.',
+            code: gate.code || 'TASKFORCE_AGENTS_UNAVAILABLE',
+        });
+        return false;
+    };
+    addRoute('GET', '/api/taskforce/agent-roles', async (req, res) => {
+        if (!guard(req, res))
+            return;
+        try {
+            const workspaceId = resolveWorkspaceId(req, undefined, requestWorkspaceId);
+            const requestUrl = new URL(req.url || '/', 'http://taskforce.local');
+            const includeRetired = requestUrl.searchParams.get('includeRetired') === 'true';
+            const store = getStore();
+            const roles = store.list(workspaceId, { includeRetired })
+                .map((role) => serializeRole(store, workspaceId, role));
+            writeJson(res, 200, { success: true, roles });
+        }
+        catch (error) {
+            writeError(res, error);
+        }
+    });
+    addRoute('POST', '/api/taskforce/agent-roles', async (req, res) => {
+        if (!guard(req, res))
+            return;
+        try {
+            const body = await parseJsonBody(req);
+            const workspaceId = resolveWorkspaceId(req, body, requestWorkspaceId);
+            const actorId = requireWorkspaceActor(req, res, workspaceId);
+            if (!actorId)
+                return;
+            const store = getStore();
+            const role = store.create({
+                workspaceId,
+                definition: body.definition,
+                actorId,
+            });
+            writeJson(res, 201, {
+                success: true,
+                role: serializeRole(store, workspaceId, role),
+            });
+        }
+        catch (error) {
+            writeError(res, error);
+        }
+    });
+    addRoute('GET', '/api/taskforce/agent-roles/:roleId', async (req, res, params) => {
+        if (!guard(req, res))
+            return;
+        try {
+            const workspaceId = resolveWorkspaceId(req, undefined, requestWorkspaceId);
+            const store = getStore();
+            const role = store.get(workspaceId, params.roleId);
+            if (!role)
+                throw new AgentRoleNotFoundError();
+            writeJson(res, 200, {
+                success: true,
+                role: serializeRole(store, workspaceId, role),
+            });
+        }
+        catch (error) {
+            writeError(res, error);
+        }
+    });
+    addRoute('PATCH', '/api/taskforce/agent-roles/:roleId', async (req, res, params) => {
+        if (!guard(req, res))
+            return;
+        try {
+            const body = await parseJsonBody(req);
+            const workspaceId = resolveWorkspaceId(req, body, requestWorkspaceId);
+            const actorId = requireWorkspaceActor(req, res, workspaceId);
+            if (!actorId)
+                return;
+            const store = getStore();
+            const role = store.update({
+                workspaceId,
+                roleId: params.roleId,
+                definition: body.definition,
+                expectedContentHash: String(body.expectedContentHash || '').trim(),
+                actorId,
+            });
+            writeJson(res, 200, {
+                success: true,
+                role: serializeRole(store, workspaceId, role),
+            });
+        }
+        catch (error) {
+            writeError(res, error);
+        }
+    });
+    addRoute('POST', '/api/taskforce/agent-roles/:roleId/retire', async (req, res, params) => {
+        if (!guard(req, res))
+            return;
+        try {
+            const body = await parseJsonBody(req);
+            if (body.confirm !== true) {
+                writeJson(res, 400, {
+                    success: false,
+                    error: 'Confirm retirement before continuing.',
+                    code: 'AGENT_ROLE_RETIRE_CONFIRMATION_REQUIRED',
+                });
+                return;
+            }
+            const workspaceId = resolveWorkspaceId(req, body, requestWorkspaceId);
+            const actorId = requireWorkspaceActor(req, res, workspaceId);
+            if (!actorId)
+                return;
+            const store = getStore();
+            const role = store.retire(workspaceId, params.roleId, actorId);
+            writeJson(res, 200, {
+                success: true,
+                role: serializeRole(store, workspaceId, role),
+            });
+        }
+        catch (error) {
+            writeError(res, error);
+        }
+    });
+    addRoute('POST', '/api/taskforce/agent-roles/:roleId/restore', async (req, res, params) => {
+        if (!guard(req, res))
+            return;
+        try {
+            const body = await parseJsonBody(req);
+            const workspaceId = resolveWorkspaceId(req, body, requestWorkspaceId);
+            const actorId = requireWorkspaceActor(req, res, workspaceId);
+            if (!actorId)
+                return;
+            const store = getStore();
+            const role = store.restore(workspaceId, params.roleId, actorId);
+            writeJson(res, 200, {
+                success: true,
+                role: serializeRole(store, workspaceId, role),
+            });
+        }
+        catch (error) {
+            writeError(res, error);
+        }
+    });
+}

package/dist/server/routes/agentSkills.d.ts

@@ -0,0 +1,16 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { TaskforceCore } from '../../core/Taskforce.js';
+import { TaskforceAgentStore } from '../../storage/taskforceAgentStore.js';
+import { TaskforceAgentSkillStore } from '../../storage/taskforceAgentSkillStore.js';
+import { type RouteHandler } from './primitives.js';
+export interface AgentSkillsRouteDependencies {
+    addRoute: (method: string, path: string, handler: RouteHandler) => void;
+    ensureAppAccess: (req: IncomingMessage, res: ServerResponse) => boolean;
+    core?: TaskforceCore;
+    requestWorkspaceId?: (req: IncomingMessage) => string;
+    resolveAuthenticatedUserId?: (req: IncomingMessage) => string | null;
+    resolveAuthenticatedMutationUserId?: (req: IncomingMessage) => string | null;
+    skillStore?: TaskforceAgentSkillStore;
+    agentStore?: TaskforceAgentStore;
+}
+export declare function registerAgentSkillsRoutes(deps: AgentSkillsRouteDependencies): void;

package/dist/server/routes/agentSkills.js

@@ -0,0 +1,291 @@
+import { TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY, resolveAppGateAccess, } from '../../runtime/appGates.js';
+import { compileTaskforceAgentSkillPrompt } from '../../shared/taskforceAgentSkill.js';
+import { TaskforceAgentStore } from '../../storage/taskforceAgentStore.js';
+import { TaskforceAgentSkillConflictError, TaskforceAgentSkillStore, } from '../../storage/taskforceAgentSkillStore.js';
+import { parseJsonBody } from './primitives.js';
+import { resolveErrorStatusCode } from './shared.js';
+function writeJson(res, statusCode, payload) {
+    res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(payload));
+}
+function queryValue(req, key) {
+    try {
+        return new URL(req.url || '/', 'http://localhost').searchParams.get(key)?.trim() || '';
+    }
+    catch {
+        return '';
+    }
+}
+function resolveWorkspaceId(req, body, requestWorkspaceId) {
+    const authoritativeWorkspaceId = String(requestWorkspaceId?.(req) || '').trim();
+    const requestedWorkspaceId = String(body?.workspaceId || queryValue(req, 'workspaceId') || '').trim();
+    if (authoritativeWorkspaceId
+        && requestedWorkspaceId
+        && requestedWorkspaceId !== authoritativeWorkspaceId) {
+        throw Object.assign(new Error('The requested workspace does not match the authorized workspace.'), { statusCode: 403, code: 'TASKFORCE_AGENT_SKILL_WORKSPACE_FORBIDDEN' });
+    }
+    return authoritativeWorkspaceId || requestedWorkspaceId || 'default';
+}
+function serializeSkill(skill, usage) {
+    return {
+        id: skill.id,
+        workspaceId: skill.workspaceId,
+        lifecycleStatus: skill.lifecycleStatus,
+        definition: skill.definition,
+        revision: skill.revision,
+        contentHash: skill.contentHash,
+        promptContent: compileTaskforceAgentSkillPrompt(skill.definition),
+        revisions: (skill.revisions || []).map((revision) => ({
+            revision: revision.revision,
+            contentHash: revision.contentHash,
+            createdByActorId: revision.createdByActorId,
+            createdAt: revision.createdAt,
+        })),
+        usage,
+        createdByActorId: skill.createdByActorId,
+        updatedByActorId: skill.updatedByActorId,
+        createdAt: skill.createdAt,
+        updatedAt: skill.updatedAt,
+        retiredAt: skill.retiredAt,
+        retiredByActorId: skill.retiredByActorId,
+    };
+}
+export function registerAgentSkillsRoutes(deps) {
+    const { addRoute, ensureAppAccess, core, requestWorkspaceId, resolveAuthenticatedUserId, resolveAuthenticatedMutationUserId, } = deps;
+    let skillStore = deps.skillStore || null;
+    let agentStore = deps.agentStore || null;
+    const getSkillStore = () => {
+        if (skillStore)
+            return skillStore;
+        if (!core)
+            throw new Error('Taskforce Agent Skill store is unavailable.');
+        skillStore = new TaskforceAgentSkillStore(core.getDatabaseAdapter(), core.getTenantId());
+        return skillStore;
+    };
+    const getAgentStore = () => {
+        if (agentStore)
+            return agentStore;
+        if (!core)
+            return null;
+        agentStore = new TaskforceAgentStore(core.getDatabaseAdapter(), core.getTenantId());
+        return agentStore;
+    };
+    const ensureFeatureAccess = (req, res) => {
+        if (!ensureAppAccess(req, res))
+            return false;
+        const gate = resolveAppGateAccess(TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY);
+        if (gate.allowed)
+            return true;
+        writeJson(res, 403, {
+            success: false,
+            error: 'Taskforce Agents are unavailable for this workspace.',
+            code: gate.code || 'TASKFORCE_AGENTS_UNAVAILABLE',
+        });
+        return false;
+    };
+    const usageFor = (workspaceId, skillId) => {
+        const agents = getAgentStore()?.list(workspaceId) || [];
+        return {
+            agentCount: agents.filter((agent) => (agent.definition?.skillRefs.some((reference) => reference.id === skillId))).length,
+            // Workflow Skill references are not owned by T-979 yet. Report unavailable
+            // instead of a false zero until the Workflow contract exposes them.
+            workflowCount: null,
+        };
+    };
+    const requireWorkspaceActor = (req, res, workspaceId, options) => {
+        let actorId = '';
+        try {
+            const resolveActorId = options?.mutation
+                ? resolveAuthenticatedMutationUserId
+                : resolveAuthenticatedUserId;
+            actorId = String(resolveActorId?.(req) || '').trim();
+        }
+        catch (error) {
+            writeJson(res, resolveErrorStatusCode(error, 401), {
+                success: false,
+                error: String(error?.message || 'Authentication is required.'),
+                code: String(error?.code || 'MUTATION_AUTH_REQUIRED'),
+            });
+            return null;
+        }
+        if (!actorId) {
+            writeJson(res, 401, {
+                success: false,
+                error: 'Authentication is required to manage Skills.',
+                code: 'MUTATION_AUTH_REQUIRED',
+            });
+            return null;
+        }
+        if (core) {
+            const membership = core.listWorkspaceUsers(workspaceId)
+                .find((candidate) => candidate.userId === actorId);
+            if (!membership
+                || membership.disabled === true
+                || String(membership.status || '').toLowerCase() !== 'active') {
+                writeJson(res, 403, {
+                    success: false,
+                    error: 'Workspace membership is required to access Skills.',
+                    code: 'TASKFORCE_AGENT_SKILL_WORKSPACE_FORBIDDEN',
+                });
+                return null;
+            }
+            if (options?.mutation
+                && (String(membership.role || '').toLowerCase() === 'read-only'
+                    || String(membership.permissionMode || '').toLowerCase() === 'read-only')) {
+                writeJson(res, 403, {
+                    success: false,
+                    error: 'Read-only workspace members cannot manage Skills.',
+                    code: 'TASKFORCE_AGENT_SKILL_WRITE_FORBIDDEN',
+                });
+                return null;
+            }
+        }
+        return actorId;
+    };
+    const writeMutationError = (res, error) => {
+        if (error instanceof TaskforceAgentSkillConflictError) {
+            writeJson(res, 409, {
+                success: false,
+                error: error.message,
+                code: error.code,
+                currentRevision: error.currentRevision,
+                currentContentHash: error.currentContentHash,
+            });
+            return;
+        }
+        const candidate = error;
+        writeJson(res, resolveErrorStatusCode(error, 500), {
+            success: false,
+            error: String(candidate?.message || error || 'Unable to save Skill.'),
+            ...(candidate?.code ? { code: candidate.code } : {}),
+            ...(Array.isArray(candidate?.issues) ? { issues: candidate.issues } : {}),
+        });
+    };
+    addRoute('GET', '/api/taskforce/agent-skills', async (req, res) => {
+        if (!ensureFeatureAccess(req, res))
+            return;
+        try {
+            const workspaceId = resolveWorkspaceId(req, undefined, requestWorkspaceId);
+            if (!requireWorkspaceActor(req, res, workspaceId))
+                return;
+            const includeRetired = queryValue(req, 'includeRetired') === 'true';
+            const skills = getSkillStore()
+                .list(workspaceId, { includeRetired, includeRevisions: true })
+                .map((skill) => serializeSkill(skill, usageFor(workspaceId, skill.id)));
+            writeJson(res, 200, { success: true, skills });
+        }
+        catch (error) {
+            writeMutationError(res, error);
+        }
+    });
+    addRoute('GET', '/api/taskforce/agent-skills/:skillId', async (req, res, params) => {
+        if (!ensureFeatureAccess(req, res))
+            return;
+        try {
+            const workspaceId = resolveWorkspaceId(req, undefined, requestWorkspaceId);
+            if (!requireWorkspaceActor(req, res, workspaceId))
+                return;
+            const skill = getSkillStore().get(workspaceId, params.skillId, { includeRevisions: true });
+            if (!skill) {
+                writeJson(res, 404, {
+                    success: false,
+                    error: 'Skill not found.',
+                    code: 'TASKFORCE_AGENT_SKILL_NOT_FOUND',
+                });
+                return;
+            }
+            writeJson(res, 200, {
+                success: true,
+                skill: serializeSkill(skill, usageFor(workspaceId, skill.id)),
+            });
+        }
+        catch (error) {
+            writeMutationError(res, error);
+        }
+    });
+    addRoute('POST', '/api/taskforce/agent-skills', async (req, res) => {
+        if (!ensureFeatureAccess(req, res))
+            return;
+        try {
+            const body = await parseJsonBody(req);
+            const workspaceId = resolveWorkspaceId(req, body, requestWorkspaceId);
+            const actorId = requireWorkspaceActor(req, res, workspaceId, { mutation: true });
+            if (!actorId)
+                return;
+            const skill = getSkillStore().create({
+                workspaceId,
+                definition: body.definition,
+                actorId,
+            });
+            writeJson(res, 201, {
+                success: true,
+                skill: serializeSkill(skill, usageFor(workspaceId, skill.id)),
+            });
+        }
+        catch (error) {
+            writeMutationError(res, error);
+        }
+    });
+    addRoute('PATCH', '/api/taskforce/agent-skills/:skillId', async (req, res, params) => {
+        if (!ensureFeatureAccess(req, res))
+            return;
+        try {
+            const body = await parseJsonBody(req);
+            const workspaceId = resolveWorkspaceId(req, body, requestWorkspaceId);
+            const actorId = requireWorkspaceActor(req, res, workspaceId, { mutation: true });
+            if (!actorId)
+                return;
+            const skill = getSkillStore().update(workspaceId, params.skillId, {
+                definition: body.definition,
+                expectedContentHash: String(body.expectedContentHash || '').trim(),
+                actorId,
+            });
+            if (!skill) {
+                writeJson(res, 404, {
+                    success: false,
+                    error: 'Skill not found.',
+                    code: 'TASKFORCE_AGENT_SKILL_NOT_FOUND',
+                });
+                return;
+            }
+            writeJson(res, 200, {
+                success: true,
+                skill: serializeSkill(skill, usageFor(workspaceId, skill.id)),
+            });
+        }
+        catch (error) {
+            writeMutationError(res, error);
+        }
+    });
+    for (const action of ['retire', 'restore']) {
+        addRoute('POST', `/api/taskforce/agent-skills/:skillId/${action}`, async (req, res, params) => {
+            if (!ensureFeatureAccess(req, res))
+                return;
+            try {
+                const body = await parseJsonBody(req);
+                const workspaceId = resolveWorkspaceId(req, body, requestWorkspaceId);
+                const actorId = requireWorkspaceActor(req, res, workspaceId, { mutation: true });
+                if (!actorId)
+                    return;
+                const skill = action === 'retire'
+                    ? getSkillStore().retire(workspaceId, params.skillId, actorId)
+                    : getSkillStore().restore(workspaceId, params.skillId, actorId);
+                if (!skill) {
+                    writeJson(res, 404, {
+                        success: false,
+                        error: 'Skill not found.',
+                        code: 'TASKFORCE_AGENT_SKILL_NOT_FOUND',
+                    });
+                    return;
+                }
+                writeJson(res, 200, {
+                    success: true,
+                    skill: serializeSkill(skill, usageFor(workspaceId, skill.id)),
+                });
+            }
+            catch (error) {
+                writeMutationError(res, error);
+            }
+        });
+    }
+}

package/dist/server/routes/agents.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Taskforce Agents route module.
+ *
+ * Routes registered here:
+ *   GET    /api/taskforce/agents
+ *   POST   /api/taskforce/agents
+ *   PATCH  /api/taskforce/agents/:agentId
+ *   DELETE /api/taskforce/agents/:agentId
+ *   GET    /api/taskforce/agents/:agentId/conversations
+ *   POST   /api/taskforce/agents/:agentId/conversation/new
+ *   POST   /api/taskforce/agents/model-gateway/test
+ *   PATCH  /api/taskforce/agents/:agentId/conversations/:conversationId
+ */
+import type { IncomingMessage, ServerResponse } from 'http';
+import type { TaskforceCore } from '../../core/Taskforce.js';
+import { saveAiProfileAvatarAssets, type AiProfileAvatarAssetDeps } from '../aiProfileAvatarAssets.js';
+import type { ModelGateway, ModelGatewaySelection } from '../../services/modelGateway.js';
+import { type TaskforceAgentAvatarImageProvider } from '../../services/taskforceAgentAvatarImageProvider.js';
+import { type PreparedTaskforceAgentMcpBridge, type PrepareTaskforceAgentMcpBridgeInput, type TaskforceAgentMcpToolResult } from '../../services/taskforceAgentMcpBridge.js';
+import { TaskforceAgentConversationStore } from '../../storage/taskforceAgentConversationStore.js';
+import { TaskforceAgentStore } from '../../storage/taskforceAgentStore.js';
+import { TaskforceAgentSkillStore } from '../../storage/taskforceAgentSkillStore.js';
+import { type TaskforceAgentRuntimeReferenceResolvers } from '../../shared/taskforceAgentRuntimeResolution.js';
+import { type RouteHandler } from './primitives.js';
+type SaveAiProfileAvatarAssets = typeof saveAiProfileAvatarAssets;
+type ResolveWorkflowCompletionProjection = typeof serializeWorkflowCompletionProjection;
+export interface AgentsRouteDependencies {
+    addRoute: (method: string, path: string, handler: RouteHandler) => void;
+    ensureAppAccess: (req: IncomingMessage, res: ServerResponse) => boolean;
+    core?: TaskforceCore;
+    requestWorkspaceId?: (req: IncomingMessage) => string;
+    resolveAuthenticatedUserId?: (req: IncomingMessage) => string | null;
+    resolveRuntimeMode?: (req: IncomingMessage) => 'local' | 'cloud';
+    ensureWorkspaceAdminRole?: (req: IncomingMessage, workspaceIdOverride?: string | null) => boolean;
+    agentStore?: TaskforceAgentStore;
+    skillStore?: TaskforceAgentSkillStore;
+    conversationStore?: TaskforceAgentConversationStore;
+    createModelGateway?: (selection?: ModelGatewaySelection) => ModelGateway;
+    prepareMcpBridge?: (input: PrepareTaskforceAgentMcpBridgeInput) => Promise<PreparedTaskforceAgentMcpBridge | null>;
+    agentRuntimeReferenceResolvers?: TaskforceAgentRuntimeReferenceResolvers;
+    agentRuntimeReferenceResolversForWorkspace?: (workspaceId: string) => TaskforceAgentRuntimeReferenceResolvers;
+    aiProfileAvatarAssetDeps?: AiProfileAvatarAssetDeps;
+    avatarImageProvider?: TaskforceAgentAvatarImageProvider;
+    saveAiProfileAvatarAssets?: SaveAiProfileAvatarAssets;
+    resolveWorkflowCompletionProjection?: ResolveWorkflowCompletionProjection;
+}
+export declare function serializeWorkflowCompletionProjection(core: TaskforceCore | undefined, workspaceId: string, _taskId: string | null, toolResults: TaskforceAgentMcpToolResult[]): Record<string, unknown> | null;
+export declare function registerAgentsRoutes(deps: AgentsRouteDependencies): void;
+export {};