406 lines
14 KiB
TypeScript
406 lines
14 KiB
TypeScript
import { CreateResourceSchema, PermissionKey, UpdateResourceSchema } from "@capakraken/shared";
|
|
import type { TRPCContext } from "../../trpc.js";
|
|
import { withToolAccess, type ToolContext, type ToolDef, type ToolExecutor } from "./shared.js";
|
|
|
|
type AssistantToolErrorResult = { error: string };
|
|
|
|
type ResolvedResource = {
|
|
id: string;
|
|
eid: string;
|
|
displayName: string;
|
|
};
|
|
|
|
type ResolvedReference = {
|
|
id: string;
|
|
};
|
|
|
|
type ResourceRecord = {
|
|
id: string;
|
|
eid: string;
|
|
displayName: string;
|
|
};
|
|
|
|
type ParsedCreateResourceInput = ReturnType<typeof CreateResourceSchema.parse>;
|
|
type ParsedUpdateResourceInput = ReturnType<typeof UpdateResourceSchema.parse>;
|
|
|
|
type ResourceToolsDeps = {
|
|
assertPermission: (ctx: ToolContext, perm: PermissionKey) => void;
|
|
createResourceCaller: (ctx: TRPCContext) => {
|
|
listSummariesDetail: (params: {
|
|
search?: string;
|
|
country?: string;
|
|
metroCity?: string;
|
|
orgUnit?: string;
|
|
roleName?: string;
|
|
isActive?: boolean;
|
|
limit: number;
|
|
}) => Promise<unknown>;
|
|
getByIdentifierDetail: (params: { identifier: string }) => Promise<unknown>;
|
|
create: (params: ParsedCreateResourceInput) => Promise<ResourceRecord>;
|
|
update: (params: {
|
|
id: string;
|
|
data: ParsedUpdateResourceInput;
|
|
}) => Promise<ResourceRecord>;
|
|
deactivate: (params: { id: string }) => Promise<unknown>;
|
|
};
|
|
createRoleCaller: (ctx: TRPCContext) => {
|
|
resolveByIdentifier: (params: { identifier: string }) => Promise<ResolvedReference>;
|
|
};
|
|
createCountryCaller: (ctx: TRPCContext) => {
|
|
resolveByIdentifier: (params: { identifier: string }) => Promise<ResolvedReference>;
|
|
};
|
|
createOrgUnitCaller: (ctx: TRPCContext) => {
|
|
resolveByIdentifier: (params: { identifier: string }) => Promise<ResolvedReference>;
|
|
};
|
|
createScopedCallerContext: (ctx: ToolContext) => TRPCContext;
|
|
resolveResourceIdentifier: (
|
|
ctx: ToolContext,
|
|
identifier: string,
|
|
) => Promise<ResolvedResource | AssistantToolErrorResult>;
|
|
resolveEntityOrAssistantError: <T>(
|
|
resolve: () => Promise<T>,
|
|
notFoundMessage: string,
|
|
) => Promise<T | AssistantToolErrorResult>;
|
|
toAssistantResourceMutationError: (
|
|
error: unknown,
|
|
) => AssistantToolErrorResult | null;
|
|
toAssistantResourceCreationError: (
|
|
error: unknown,
|
|
) => AssistantToolErrorResult | null;
|
|
};
|
|
|
|
export const resourceReadToolDefinitions: ToolDef[] = withToolAccess([
|
|
{
|
|
type: "function",
|
|
function: {
|
|
name: "search_resources",
|
|
description: "Search for resources (employees) by name, employee ID, chapter, country, metro city, org unit, or role. Resource overview access required. Returns a list of matching resources with key details.",
|
|
parameters: {
|
|
type: "object",
|
|
properties: {
|
|
query: { type: "string", description: "Search term (matches displayName, eid, chapter)" },
|
|
country: { type: "string", description: "Filter by country name or code (e.g. 'Spain', 'ES', 'Deutschland', 'DE')" },
|
|
metroCity: { type: "string", description: "Filter by metro city name (e.g. 'Madrid', 'München')" },
|
|
orgUnit: { type: "string", description: "Filter by org unit name (partial match)" },
|
|
roleName: { type: "string", description: "Filter by role name (partial match)" },
|
|
isActive: { type: "boolean", description: "Filter by active status. Default: true" },
|
|
limit: { type: "integer", description: "Max results. Default: 50" },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
type: "function",
|
|
function: {
|
|
name: "get_resource",
|
|
description: "Get detailed information about a single resource by ID, employee ID (eid), or name.",
|
|
parameters: {
|
|
type: "object",
|
|
properties: {
|
|
identifier: { type: "string", description: "Resource ID, employee ID (eid like EMP-001), or display name" },
|
|
},
|
|
required: ["identifier"],
|
|
},
|
|
},
|
|
},
|
|
], {
|
|
search_resources: {
|
|
requiresResourceOverview: true,
|
|
},
|
|
});
|
|
|
|
export const resourceMutationToolDefinitions: ToolDef[] = withToolAccess([
|
|
{
|
|
type: "function",
|
|
function: {
|
|
name: "update_resource",
|
|
description: "Update a resource's details. Requires manageResources permission. Always confirm with the user before calling this.",
|
|
parameters: {
|
|
type: "object",
|
|
properties: {
|
|
id: { type: "string", description: "Resource ID, EID, or display name" },
|
|
displayName: { type: "string", description: "New display name" },
|
|
fte: { type: "number", description: "New FTE (0.0-1.0)" },
|
|
lcrCents: { type: "integer", description: "New LCR in cents (e.g. 8500 = 85.00 EUR/h)" },
|
|
chapter: { type: "string", description: "New chapter" },
|
|
chargeabilityTarget: { type: "number", description: "New chargeability target (0-100)" },
|
|
},
|
|
required: ["id"],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
type: "function",
|
|
function: {
|
|
name: "create_resource",
|
|
description: "Create a new resource/employee. Requires manageResources permission. Always confirm with the user before calling this.",
|
|
parameters: {
|
|
type: "object",
|
|
properties: {
|
|
eid: { type: "string", description: "Employee ID (e.g. EMP-001)" },
|
|
displayName: { type: "string", description: "Full name" },
|
|
email: { type: "string", description: "Email address" },
|
|
fte: { type: "number", description: "Full-time equivalent 0.0-1.0. Default: 1.0" },
|
|
lcrCents: { type: "integer", description: "Labor cost rate in cents/hour (e.g. 8500 = 85.00 EUR/h)" },
|
|
ucrCents: { type: "integer", description: "Utilization cost rate in cents/hour (optional; defaults to 70% of LCR)" },
|
|
chapter: { type: "string", description: "Chapter/department" },
|
|
chargeabilityTarget: { type: "number", description: "Target utilization percentage 0-100. Default: 80" },
|
|
roleName: { type: "string", description: "Role name to assign (e.g. 'Designer')" },
|
|
countryCode: { type: "string", description: "Country code or name (e.g. 'DE', 'Germany')" },
|
|
orgUnitName: { type: "string", description: "Organizational unit name" },
|
|
postalCode: { type: "string", description: "Postal code. If provided without federalState, state may be inferred." },
|
|
},
|
|
required: ["eid", "displayName", "lcrCents"],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
type: "function",
|
|
function: {
|
|
name: "deactivate_resource",
|
|
description: "Deactivate a resource (soft delete). Requires manageResources permission. Always confirm with the user before calling this.",
|
|
parameters: {
|
|
type: "object",
|
|
properties: {
|
|
identifier: { type: "string", description: "Resource ID, EID, or display name" },
|
|
},
|
|
required: ["identifier"],
|
|
},
|
|
},
|
|
},
|
|
], {
|
|
update_resource: {
|
|
requiredPermissions: [PermissionKey.MANAGE_RESOURCES],
|
|
},
|
|
create_resource: {
|
|
requiredPermissions: [PermissionKey.MANAGE_RESOURCES],
|
|
},
|
|
deactivate_resource: {
|
|
requiredPermissions: [PermissionKey.MANAGE_RESOURCES],
|
|
},
|
|
});
|
|
|
|
export function createResourceExecutors(
|
|
deps: ResourceToolsDeps,
|
|
): Record<string, ToolExecutor> {
|
|
return {
|
|
async search_resources(
|
|
params: {
|
|
query?: string;
|
|
country?: string;
|
|
metroCity?: string;
|
|
orgUnit?: string;
|
|
roleName?: string;
|
|
isActive?: boolean;
|
|
limit?: number;
|
|
},
|
|
ctx: ToolContext,
|
|
) {
|
|
const caller = deps.createResourceCaller(deps.createScopedCallerContext(ctx));
|
|
return caller.listSummariesDetail({
|
|
...(params.query !== undefined ? { search: params.query } : {}),
|
|
...(params.country !== undefined ? { country: params.country } : {}),
|
|
...(params.metroCity !== undefined ? { metroCity: params.metroCity } : {}),
|
|
...(params.orgUnit !== undefined ? { orgUnit: params.orgUnit } : {}),
|
|
...(params.roleName !== undefined ? { roleName: params.roleName } : {}),
|
|
isActive: params.isActive ?? true,
|
|
limit: Math.min(params.limit ?? 50, 100),
|
|
});
|
|
},
|
|
|
|
async get_resource(params: { identifier: string }, ctx: ToolContext) {
|
|
const caller = deps.createResourceCaller(deps.createScopedCallerContext(ctx));
|
|
return caller.getByIdentifierDetail({ identifier: params.identifier });
|
|
},
|
|
|
|
async update_resource(
|
|
params: {
|
|
id: string;
|
|
displayName?: string;
|
|
fte?: number;
|
|
lcrCents?: number;
|
|
chapter?: string;
|
|
chargeabilityTarget?: number;
|
|
},
|
|
ctx: ToolContext,
|
|
) {
|
|
deps.assertPermission(ctx, PermissionKey.MANAGE_RESOURCES);
|
|
const resource = await deps.resolveResourceIdentifier(ctx, params.id);
|
|
if ("error" in resource) {
|
|
return resource;
|
|
}
|
|
|
|
const caller = deps.createResourceCaller(deps.createScopedCallerContext(ctx));
|
|
const data = UpdateResourceSchema.parse({
|
|
...(params.displayName !== undefined ? { displayName: params.displayName } : {}),
|
|
...(params.fte !== undefined ? { fte: params.fte } : {}),
|
|
...(params.lcrCents !== undefined ? { lcrCents: params.lcrCents } : {}),
|
|
...(params.chapter !== undefined ? { chapter: params.chapter } : {}),
|
|
...(params.chargeabilityTarget !== undefined
|
|
? { chargeabilityTarget: params.chargeabilityTarget }
|
|
: {}),
|
|
});
|
|
|
|
const updatedFields = Object.keys(data);
|
|
if (updatedFields.length === 0) {
|
|
return { error: "No fields to update" };
|
|
}
|
|
|
|
let updated;
|
|
try {
|
|
updated = await caller.update({ id: resource.id, data });
|
|
} catch (error) {
|
|
const mapped = deps.toAssistantResourceMutationError(error);
|
|
if (mapped) {
|
|
return mapped;
|
|
}
|
|
throw error;
|
|
}
|
|
|
|
return {
|
|
__action: "invalidate",
|
|
scope: ["resource"],
|
|
success: true,
|
|
message: `Updated resource ${updated.displayName} (${updated.eid})`,
|
|
updatedFields,
|
|
};
|
|
},
|
|
|
|
async create_resource(
|
|
params: {
|
|
eid: string;
|
|
displayName: string;
|
|
email?: string;
|
|
fte?: number;
|
|
lcrCents: number;
|
|
ucrCents?: number;
|
|
chapter?: string;
|
|
chargeabilityTarget?: number;
|
|
roleName?: string;
|
|
countryCode?: string;
|
|
orgUnitName?: string;
|
|
postalCode?: string;
|
|
},
|
|
ctx: ToolContext,
|
|
) {
|
|
deps.assertPermission(ctx, PermissionKey.MANAGE_RESOURCES);
|
|
if (!params.email?.trim()) {
|
|
return { error: "email is required to create a resource." };
|
|
}
|
|
|
|
const scopedContext = deps.createScopedCallerContext(ctx);
|
|
const roleCaller = deps.createRoleCaller(scopedContext);
|
|
const countryCaller = deps.createCountryCaller(scopedContext);
|
|
const orgUnitCaller = deps.createOrgUnitCaller(scopedContext);
|
|
|
|
const data: Record<string, unknown> = {
|
|
eid: params.eid,
|
|
displayName: params.displayName,
|
|
email: params.email,
|
|
lcrCents: params.lcrCents,
|
|
ucrCents: params.ucrCents ?? Math.round(params.lcrCents * 0.7),
|
|
chargeabilityTarget: params.chargeabilityTarget ?? 80,
|
|
currency: "EUR",
|
|
availability: {
|
|
monday: 8,
|
|
tuesday: 8,
|
|
wednesday: 8,
|
|
thursday: 8,
|
|
friday: 8,
|
|
},
|
|
skills: [],
|
|
dynamicFields: {},
|
|
...(params.fte !== undefined ? { fte: params.fte } : {}),
|
|
...(params.chapter ? { chapter: params.chapter } : {}),
|
|
...(params.postalCode ? { postalCode: params.postalCode } : {}),
|
|
};
|
|
|
|
const roleIdentifier = params.roleName?.trim();
|
|
if (roleIdentifier) {
|
|
const role = await deps.resolveEntityOrAssistantError(
|
|
() => roleCaller.resolveByIdentifier({ identifier: roleIdentifier }),
|
|
`Role not found: "${roleIdentifier}"`,
|
|
);
|
|
if ("error" in role) {
|
|
return role;
|
|
}
|
|
data.roleId = role.id;
|
|
}
|
|
|
|
const countryIdentifier = params.countryCode?.trim();
|
|
if (countryIdentifier) {
|
|
const country = await deps.resolveEntityOrAssistantError(
|
|
() => countryCaller.resolveByIdentifier({ identifier: countryIdentifier }),
|
|
`Country not found: "${countryIdentifier}"`,
|
|
);
|
|
if ("error" in country) {
|
|
return country;
|
|
}
|
|
data.countryId = country.id;
|
|
}
|
|
|
|
const orgUnitIdentifier = params.orgUnitName?.trim();
|
|
if (orgUnitIdentifier) {
|
|
const orgUnit = await deps.resolveEntityOrAssistantError(
|
|
() => orgUnitCaller.resolveByIdentifier({ identifier: orgUnitIdentifier }),
|
|
`Org unit not found: "${orgUnitIdentifier}"`,
|
|
);
|
|
if ("error" in orgUnit) {
|
|
return orgUnit;
|
|
}
|
|
data.orgUnitId = orgUnit.id;
|
|
}
|
|
|
|
const input = CreateResourceSchema.parse(data);
|
|
const caller = deps.createResourceCaller(scopedContext);
|
|
let resource;
|
|
try {
|
|
resource = await caller.create(input);
|
|
} catch (error) {
|
|
const mapped = deps.toAssistantResourceCreationError(error);
|
|
if (mapped) {
|
|
return mapped;
|
|
}
|
|
throw error;
|
|
}
|
|
|
|
return {
|
|
__action: "invalidate",
|
|
scope: ["resource"],
|
|
success: true,
|
|
message: `Created resource: ${resource.displayName} (${resource.eid})`,
|
|
resourceId: resource.id,
|
|
};
|
|
},
|
|
|
|
async deactivate_resource(
|
|
params: { identifier: string },
|
|
ctx: ToolContext,
|
|
) {
|
|
deps.assertPermission(ctx, PermissionKey.MANAGE_RESOURCES);
|
|
const resource = await deps.resolveResourceIdentifier(ctx, params.identifier);
|
|
if ("error" in resource) {
|
|
return resource;
|
|
}
|
|
|
|
const caller = deps.createResourceCaller(deps.createScopedCallerContext(ctx));
|
|
try {
|
|
await caller.deactivate({ id: resource.id });
|
|
} catch (error) {
|
|
const mapped = deps.toAssistantResourceMutationError(error);
|
|
if (mapped) {
|
|
return mapped;
|
|
}
|
|
throw error;
|
|
}
|
|
|
|
return {
|
|
__action: "invalidate",
|
|
scope: ["resource"],
|
|
success: true,
|
|
message: `Deactivated resource: ${resource.displayName} (${resource.eid})`,
|
|
};
|
|
},
|
|
};
|
|
}
|