@studiometa/productive-mcp 0.8.4 → 0.9.0

package/dist/handlers-BYE2INiR.js

@@ -0,0 +1,2681 @@
+import { ProductiveApi, formatAttachment, formatBooking, formatBudget, formatComment, formatCompany, formatDeal, formatDiscussion, formatListResponse, formatPage, formatPerson, formatProject, formatService, formatTask, formatTimeEntry, formatTimer } from "@studiometa/productive-api";
+import { ResolveError, VALID_REPORT_TYPES, createBooking, createComment, createCompany, createDeal, createDiscussion, createPage, createTask, createTimeEntry, deleteAttachment, deleteDiscussion, deletePage, fromHandlerContext, getAttachment, getBooking, getBudget, getComment, getCompany, getDeal, getDiscussion, getPage, getPerson, getProject, getReport, getTask, getTimeEntry, getTimer, listAttachments, listBookings, listBudgets, listComments, listCompanies, listDeals, listDiscussions, listPages, listPeople, listProjects, listServices, listTasks, listTimeEntries, listTimers, reopenDiscussion, resolveDiscussion, resolveResource, startTimer, stopTimer, updateBooking, updateComment, updateCompany, updateDeal, updateDiscussion, updatePage, updateTask, updateTimeEntry } from "@studiometa/productive-core";
+/**
+* Custom error classes for MCP server
+*
+* These provide structured error handling with LLM-friendly messages
+* that include guidance on how to resolve issues.
+*/
+/**
+* Error thrown when user input validation fails.
+* These errors should be returned to the user directly.
+*
+* Includes optional hints for how to resolve the issue.
+*/
+var UserInputError = class extends Error {
+	hints;
+	constructor(message, hints) {
+		super(message);
+		this.name = "UserInputError";
+		this.hints = hints;
+	}
+	/**
+	* Format error message with hints for LLM consumption
+	*/
+	toFormattedMessage() {
+		let msg = `**Input Error:** ${this.message}`;
+		if (this.hints && this.hints.length > 0) msg += "\n\n**Hints:**\n" + this.hints.map((h) => `- ${h}`).join("\n");
+		return msg;
+	}
+};
+/**
+* Error messages with guidance for common validation failures
+*/
+const ErrorMessages = {
+	missingId: (action) => new UserInputError(`id is required for ${action} action`, [`Use action="list" first to find the resource ID`, `Then use action="${action}" with the id parameter`]),
+	missingRequiredFields: (resource, fields) => new UserInputError(`${fields.join(", ")} ${fields.length === 1 ? "is" : "are"} required for creating ${resource}`, [`Provide all required fields: ${fields.join(", ")}`, `Use action="help" for detailed documentation on ${resource}`]),
+	invalidAction: (action, resource, validActions) => new UserInputError(`Invalid action "${action}" for ${resource}`, [`Valid actions are: ${validActions.join(", ")}`, `Use action="help" with resource="${resource}" for detailed documentation`]),
+	unknownResource: (resource, validResources) => new UserInputError(`Unknown resource: ${resource}`, [`Valid resources are: ${validResources.join(", ")}`, `Use action="help" without a resource for an overview of all resources`]),
+	missingReportType: () => new UserInputError("report_type is required for reports", ["Specify report_type parameter (e.g., \"time_reports\", \"project_reports\")", "Use action=\"help\" with resource=\"reports\" for available report types"]),
+	invalidReportType: (reportType, validTypes) => new UserInputError(`Invalid report_type: ${reportType}`, [`Valid report types are: ${validTypes.join(", ")}`, "Use action=\"help\" with resource=\"reports\" for detailed documentation"]),
+	missingServiceForTimer: () => new UserInputError("service_id is required to start a timer", ["First find a service using resource=\"services\" action=\"list\"", "Then start the timer with the service_id"]),
+	noUserIdConfigured: () => new UserInputError("User ID not configured", ["The \"me\" action requires a user ID to be configured", "Use action=\"list\" to find people, or configure the user ID"]),
+	missingCommentTarget: () => new UserInputError("A target is required for creating a comment", ["Provide one of: task_id, deal_id, or company_id", "Find targets using resource=\"tasks\", \"deals\", or \"companies\" with action=\"list\""]),
+	missingBookingTarget: () => new UserInputError("A service or event is required for creating a booking", ["Provide either: service_id or event_id", "Find services using resource=\"services\" with action=\"list\""]),
+	apiError: (statusCode, message) => {
+		const hints = [];
+		if (statusCode === 401) {
+			hints.push("Check that your API token is valid and not expired");
+			hints.push("Verify the organization ID is correct");
+		} else if (statusCode === 403) {
+			hints.push("You may not have permission to access this resource");
+			hints.push("Check your API token permissions");
+		} else if (statusCode === 404) {
+			hints.push("The resource may not exist or you may not have access");
+			hints.push("Verify the resource ID is correct");
+			hints.push("Use action=\"list\" to find valid resource IDs");
+		} else if (statusCode === 422) {
+			hints.push("The request data may be invalid");
+			hints.push("Check the field values and types");
+			hints.push("Use action=\"help\" for field documentation");
+		} else if (statusCode >= 500) hints.push("This is a server error - try again later");
+		return new UserInputError(`API error (${statusCode}): ${message}`, hints);
+	}
+};
+/**
+* Check if an error is a UserInputError
+*/
+function isUserInputError(error) {
+	return error instanceof UserInputError;
+}
+/**
+* Response formatters for agent-friendly output
+*
+* This module re-exports formatters from @studiometa/productive-api
+* with MCP-specific defaults (no relationship IDs, no timestamps).
+*
+* Supports compact mode to reduce token usage by omitting verbose fields
+* like descriptions and notes from list responses.
+*/
+/**
+* MCP-specific format options
+* - No relationship IDs (cleaner output for agents)
+* - No timestamps (reduce noise)
+* - HTML stripping enabled
+*/
+var MCP_FORMAT_OPTIONS = {
+	includeRelationshipIds: false,
+	includeTimestamps: false,
+	stripHtml: true
+};
+/**
+* Remove verbose fields from an object for compact output
+*/
+function compactify(obj, fieldsToRemove) {
+	const result = { ...obj };
+	for (const field of fieldsToRemove) delete result[field];
+	return result;
+}
+/**
+* Format time entry for agent consumption
+*/
+function formatTimeEntry$1(entry, options) {
+	const result = formatTimeEntry(entry, MCP_FORMAT_OPTIONS);
+	if (options?.compact) return compactify(result, [
+		"note",
+		"billable_time",
+		"approved"
+	]);
+	return result;
+}
+/**
+* Format project for agent consumption
+*/
+function formatProject$1(project, options) {
+	const result = formatProject(project, MCP_FORMAT_OPTIONS);
+	if (options?.compact) return compactify(result, ["budget"]);
+	return result;
+}
+/**
+* Format task for agent consumption
+* Tasks use included resources to resolve project/company names
+*/
+function formatTask$1(task, options) {
+	const result = formatTask(task, {
+		...MCP_FORMAT_OPTIONS,
+		included: options?.included
+	});
+	if (options?.compact) return compactify(result, [
+		"description",
+		"initial_estimate",
+		"worked_time",
+		"remaining_time",
+		"project",
+		"company"
+	]);
+	return result;
+}
+/**
+* Format person for agent consumption
+*/
+function formatPerson$1(person, options) {
+	const result = formatPerson(person, MCP_FORMAT_OPTIONS);
+	if (options?.compact) return compactify(result, [
+		"title",
+		"first_name",
+		"last_name"
+	]);
+	return result;
+}
+/**
+* Format service for agent consumption
+*/
+function formatService$1(service, options) {
+	const result = formatService(service, MCP_FORMAT_OPTIONS);
+	if (options?.compact) return compactify(result, ["budgeted_time", "worked_time"]);
+	return result;
+}
+/**
+* Format budget for agent consumption
+*/
+function formatBudget$1(budget, options) {
+	const result = formatBudget(budget, MCP_FORMAT_OPTIONS);
+	if (options?.compact) return compactify(result, ["budget_type", "currency"]);
+	return result;
+}
+/**
+* Format company for agent consumption
+*/
+function formatCompany$1(company, options) {
+	const result = formatCompany(company, MCP_FORMAT_OPTIONS);
+	if (options?.compact) return compactify(result, [
+		"billing_name",
+		"domain",
+		"due_days"
+	]);
+	return result;
+}
+/**
+* Format comment for agent consumption
+*/
+function formatComment$1(comment, options) {
+	return formatComment(comment, {
+		...MCP_FORMAT_OPTIONS,
+		included: options?.included
+	});
+}
+/**
+* Format timer for agent consumption
+*/
+function formatTimer$1(timer, _options) {
+	return formatTimer(timer, MCP_FORMAT_OPTIONS);
+}
+/**
+* Format deal for agent consumption
+*/
+function formatDeal$1(deal, options) {
+	const result = formatDeal(deal, {
+		...MCP_FORMAT_OPTIONS,
+		included: options?.included
+	});
+	if (options?.compact) return compactify(result, ["won_at", "lost_at"]);
+	return result;
+}
+/**
+* Format booking for agent consumption
+*/
+function formatBooking$1(booking, options) {
+	const result = formatBooking(booking, {
+		...MCP_FORMAT_OPTIONS,
+		included: options?.included
+	});
+	if (options?.compact) return compactify(result, [
+		"approved_at",
+		"rejected_at",
+		"rejected_reason"
+	]);
+	return result;
+}
+/**
+* Format attachment for agent consumption
+*/
+function formatAttachment$1(attachment, options) {
+	const result = formatAttachment(attachment, MCP_FORMAT_OPTIONS);
+	if (options?.compact) return compactify(result, ["url"]);
+	return result;
+}
+/**
+* Format page for agent consumption
+*/
+function formatPage$1(page, options) {
+	const result = formatPage(page, MCP_FORMAT_OPTIONS);
+	if (options?.compact) return compactify(result, ["body", "version_number"]);
+	return result;
+}
+/**
+* Format discussion for agent consumption
+*/
+function formatDiscussion$1(discussion, options) {
+	const result = formatDiscussion(discussion, MCP_FORMAT_OPTIONS);
+	if (options?.compact) return compactify(result, ["body"]);
+	return result;
+}
+/**
+* Format list response with pagination
+*
+* @param data - Array of JSON:API resources
+* @param formatter - Formatter function (item, options?) => T
+* @param meta - Pagination metadata
+* @param options - MCP format options (compact, included)
+*/
+function formatListResponse$1(data, formatter, meta, options) {
+	const wrappedFormatter = (item, _cliOptions) => {
+		return formatter(item, options);
+	};
+	return formatListResponse(data, wrappedFormatter, meta, {
+		...MCP_FORMAT_OPTIONS,
+		included: options?.included
+	});
+}
+/**
+* Generate hints for a task
+*/
+function getTaskHints(taskId, serviceId) {
+	const hints = {
+		related_resources: [
+			{
+				resource: "comments",
+				description: "Get comments on this task",
+				example: {
+					resource: "comments",
+					action: "list",
+					filter: { task_id: taskId }
+				}
+			},
+			{
+				resource: "time",
+				description: "Get time entries logged on this task",
+				example: {
+					resource: "time",
+					action: "list",
+					filter: { task_id: taskId }
+				}
+			},
+			{
+				resource: "tasks",
+				description: "Get subtasks of this task",
+				example: {
+					resource: "tasks",
+					action: "list",
+					filter: { parent_task_id: taskId }
+				}
+			}
+		],
+		common_actions: [{
+			action: "Add a comment",
+			example: {
+				resource: "comments",
+				action: "create",
+				task_id: taskId,
+				body: "<your comment>"
+			}
+		}]
+	};
+	if (serviceId) hints.common_actions.push({
+		action: "Log time on this task",
+		example: {
+			resource: "time",
+			action: "create",
+			service_id: serviceId,
+			task_id: taskId,
+			date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+			time: 60,
+			note: "<description of work>"
+		}
+	});
+	return hints;
+}
+/**
+* Generate hints for a project
+*/
+function getProjectHints(projectId) {
+	return {
+		related_resources: [
+			{
+				resource: "tasks",
+				description: "Get tasks in this project",
+				example: {
+					resource: "tasks",
+					action: "list",
+					filter: { project_id: projectId }
+				}
+			},
+			{
+				resource: "services",
+				description: "Get services (budget lines) for this project",
+				example: {
+					resource: "services",
+					action: "list",
+					filter: { project_id: projectId }
+				}
+			},
+			{
+				resource: "time",
+				description: "Get time entries for this project",
+				example: {
+					resource: "time",
+					action: "list",
+					filter: { project_id: projectId }
+				}
+			},
+			{
+				resource: "comments",
+				description: "Get comments on this project",
+				example: {
+					resource: "comments",
+					action: "list",
+					filter: { project_id: projectId }
+				}
+			},
+			{
+				resource: "deals",
+				description: "Get deals/budgets for this project",
+				example: {
+					resource: "deals",
+					action: "list",
+					filter: { project_id: projectId }
+				}
+			}
+		],
+		common_actions: [{
+			action: "Create a task",
+			example: {
+				resource: "tasks",
+				action: "create",
+				project_id: projectId,
+				task_list_id: "<task_list_id>",
+				title: "<task title>"
+			}
+		}]
+	};
+}
+/**
+* Generate hints for a deal/budget
+*/
+function getDealHints(dealId) {
+	return {
+		related_resources: [
+			{
+				resource: "comments",
+				description: "Get comments on this deal/budget",
+				example: {
+					resource: "comments",
+					action: "list",
+					filter: { deal_id: dealId }
+				}
+			},
+			{
+				resource: "services",
+				description: "Get services (budget lines) for this deal",
+				example: {
+					resource: "services",
+					action: "list",
+					filter: { deal_id: dealId }
+				}
+			},
+			{
+				resource: "time",
+				description: "Get time entries for this deal/budget",
+				example: {
+					resource: "time",
+					action: "list",
+					filter: { deal_id: dealId }
+				}
+			},
+			{
+				resource: "bookings",
+				description: "Get resource bookings for this deal",
+				example: {
+					resource: "bookings",
+					action: "list",
+					filter: { deal_id: dealId }
+				}
+			}
+		],
+		common_actions: [{
+			action: "Add a comment",
+			example: {
+				resource: "comments",
+				action: "create",
+				deal_id: dealId,
+				body: "<your comment>"
+			}
+		}]
+	};
+}
+/**
+* Generate hints for a budget
+*/
+function getBudgetHints(budgetId) {
+	return { related_resources: [
+		{
+			resource: "services",
+			description: "Get services (budget lines) for this budget",
+			example: {
+				resource: "services",
+				action: "list",
+				filter: { budget_id: budgetId }
+			}
+		},
+		{
+			resource: "time",
+			description: "Get time entries for this budget",
+			example: {
+				resource: "time",
+				action: "list",
+				filter: { budget_id: budgetId }
+			}
+		},
+		{
+			resource: "bookings",
+			description: "Get bookings for this budget",
+			example: {
+				resource: "bookings",
+				action: "list",
+				filter: { budget_id: budgetId }
+			}
+		}
+	] };
+}
+/**
+* Generate hints for a person
+*/
+function getPersonHints(personId) {
+	return { related_resources: [
+		{
+			resource: "tasks",
+			description: "Get tasks assigned to this person",
+			example: {
+				resource: "tasks",
+				action: "list",
+				filter: { assignee_id: personId }
+			}
+		},
+		{
+			resource: "time",
+			description: "Get time entries by this person",
+			example: {
+				resource: "time",
+				action: "list",
+				filter: { person_id: personId }
+			}
+		},
+		{
+			resource: "bookings",
+			description: "Get bookings for this person",
+			example: {
+				resource: "bookings",
+				action: "list",
+				filter: { person_id: personId }
+			}
+		},
+		{
+			resource: "timers",
+			description: "Get active timers for this person",
+			example: {
+				resource: "timers",
+				action: "list",
+				filter: { person_id: personId }
+			}
+		}
+	] };
+}
+/**
+* Generate hints for a company
+*/
+function getCompanyHints(companyId) {
+	return { related_resources: [
+		{
+			resource: "projects",
+			description: "Get projects for this company",
+			example: {
+				resource: "projects",
+				action: "list",
+				filter: { company_id: companyId }
+			}
+		},
+		{
+			resource: "deals",
+			description: "Get deals for this company",
+			example: {
+				resource: "deals",
+				action: "list",
+				filter: { company_id: companyId }
+			}
+		},
+		{
+			resource: "tasks",
+			description: "Get tasks for this company",
+			example: {
+				resource: "tasks",
+				action: "list",
+				filter: { company_id: companyId }
+			}
+		},
+		{
+			resource: "people",
+			description: "Get contacts at this company",
+			example: {
+				resource: "people",
+				action: "list",
+				filter: { company_id: companyId }
+			}
+		}
+	] };
+}
+/**
+* Generate hints for a time entry
+*/
+function getTimeEntryHints(timeEntryId, taskId, serviceId) {
+	const hints = {
+		related_resources: [],
+		common_actions: [{
+			action: "Update this time entry",
+			example: {
+				resource: "time",
+				action: "update",
+				id: timeEntryId,
+				time: 120,
+				note: "<updated note>"
+			}
+		}]
+	};
+	if (taskId) hints.related_resources.push({
+		resource: "tasks",
+		description: "Get the associated task",
+		example: {
+			resource: "tasks",
+			action: "get",
+			id: taskId
+		}
+	});
+	if (serviceId) hints.related_resources.push({
+		resource: "services",
+		description: "Get the associated service",
+		example: {
+			resource: "services",
+			action: "get",
+			id: serviceId
+		}
+	});
+	return hints;
+}
+/**
+* Generate hints for a comment
+*/
+function getCommentHints(_commentId, commentableType, commentableId) {
+	const hints = { related_resources: [] };
+	if (commentableType && commentableId) {
+		const resource = {
+			task: "tasks",
+			deal: "deals",
+			project: "projects",
+			company: "companies"
+		}[commentableType];
+		if (resource) hints.related_resources.push({
+			resource,
+			description: `Get the ${commentableType} this comment is on`,
+			example: {
+				resource,
+				action: "get",
+				id: commentableId
+			}
+		});
+	}
+	return hints;
+}
+/**
+* Generate hints for an attachment
+*/
+function getAttachmentHints(_attachmentId, attachableType) {
+	const hints = {
+		related_resources: [],
+		common_actions: [{
+			action: "Delete this attachment",
+			example: {
+				resource: "attachments",
+				action: "delete",
+				id: _attachmentId
+			}
+		}]
+	};
+	if (attachableType) {
+		const resource = {
+			Task: "tasks",
+			Comment: "comments",
+			Deal: "deals",
+			Page: "projects"
+		}[attachableType];
+		if (resource) hints.related_resources.push({
+			resource,
+			description: `View the ${attachableType.toLowerCase()} this attachment belongs to`,
+			example: {
+				resource,
+				action: "list"
+			}
+		});
+	}
+	return hints;
+}
+/**
+* Generate hints for a booking
+*/
+function getBookingHints(bookingId, personId) {
+	const hints = {
+		related_resources: [],
+		common_actions: [{
+			action: "Update this booking",
+			example: {
+				resource: "bookings",
+				action: "update",
+				id: bookingId,
+				time: 480
+			}
+		}]
+	};
+	if (personId) hints.related_resources.push({
+		resource: "people",
+		description: "Get the person this booking is for",
+		example: {
+			resource: "people",
+			action: "get",
+			id: personId
+		}
+	});
+	return hints;
+}
+/**
+* Generate hints for a page
+*/
+function getPageHints(pageId) {
+	return {
+		related_resources: [
+			{
+				resource: "discussions",
+				description: "Get discussions on this page",
+				example: {
+					resource: "discussions",
+					action: "list",
+					filter: { page_id: pageId }
+				}
+			},
+			{
+				resource: "comments",
+				description: "Get comments on this page",
+				example: {
+					resource: "comments",
+					action: "list",
+					filter: { page_id: pageId }
+				}
+			},
+			{
+				resource: "pages",
+				description: "Get sub-pages of this page",
+				example: {
+					resource: "pages",
+					action: "list",
+					filter: { parent_page_id: pageId }
+				}
+			}
+		],
+		common_actions: [{
+			action: "Create a discussion",
+			example: {
+				resource: "discussions",
+				action: "create",
+				page_id: pageId,
+				body: "<your discussion>"
+			}
+		}, {
+			action: "Create a sub-page",
+			example: {
+				resource: "pages",
+				action: "create",
+				parent_page_id: pageId,
+				title: "<sub-page title>",
+				project_id: "<project_id>"
+			}
+		}]
+	};
+}
+/**
+* Generate hints for a discussion
+*/
+function getDiscussionHints(discussionId, pageId) {
+	const hints = {
+		related_resources: [{
+			resource: "comments",
+			description: "Get comments on this discussion",
+			example: {
+				resource: "comments",
+				action: "list",
+				filter: { discussion_id: discussionId }
+			}
+		}],
+		common_actions: [{
+			action: "Resolve this discussion",
+			example: {
+				resource: "discussions",
+				action: "resolve",
+				id: discussionId
+			}
+		}, {
+			action: "Add a comment",
+			example: {
+				resource: "comments",
+				action: "create",
+				discussion_id: discussionId,
+				body: "<your comment>"
+			}
+		}]
+	};
+	if (pageId) hints.related_resources.push({
+		resource: "pages",
+		description: "Get the page this discussion is on",
+		example: {
+			resource: "pages",
+			action: "get",
+			id: pageId
+		}
+	});
+	return hints;
+}
+/**
+* Generate hints for a timer
+*/
+function getTimerHints(timerId, serviceId) {
+	const hints = {
+		common_actions: [{
+			action: "Stop this timer",
+			example: {
+				resource: "timers",
+				action: "stop",
+				id: timerId
+			}
+		}],
+		related_resources: []
+	};
+	if (serviceId) hints.related_resources.push({
+		resource: "services",
+		description: "Get the service this timer is running on",
+		example: {
+			resource: "services",
+			action: "get",
+			id: serviceId
+		}
+	});
+	return hints;
+}
+/**
+* Helper to create a successful JSON response
+*/
+function jsonResult(data) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(data, null, 2)
+	}] };
+}
+/**
+* Helper to create an error response from a string message
+*/
+function errorResult(message) {
+	return {
+		content: [{
+			type: "text",
+			text: `**Error:** ${message}`
+		}],
+		isError: true
+	};
+}
+/**
+* Helper to create an error response from a UserInputError
+* Includes formatted hints for LLM consumption
+*/
+function inputErrorResult(error) {
+	return {
+		content: [{
+			type: "text",
+			text: error.toFormattedMessage()
+		}],
+		isError: true
+	};
+}
+/**
+* Helper to create an error response from any error type
+* Automatically formats UserInputError with hints
+*/
+function formatError(error) {
+	if (isUserInputError(error)) return inputErrorResult(error);
+	return errorResult(error instanceof Error ? error.message : String(error));
+}
+/**
+* Convert unknown filter to string filter for API
+*/
+function toStringFilter(filter) {
+	if (!filter) return void 0;
+	const result = {};
+	for (const [key, value] of Object.entries(filter)) if (value !== void 0 && value !== null) result[key] = String(value);
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+/**
+* Attachments MCP handler.
+*/
+var VALID_ACTIONS$14 = [
+	"list",
+	"get",
+	"delete"
+];
+async function handleAttachments(action, args, ctx) {
+	const { formatOptions, filter, page, perPage } = ctx;
+	const { id, task_id, comment_id, deal_id } = args;
+	const execCtx = ctx.executor();
+	if (action === "get") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+		const result = await getAttachment({ id }, execCtx);
+		const formatted = formatAttachment$1(result.data, formatOptions);
+		if (ctx.includeHints !== false) {
+			const attachableType = result.data.attributes?.attachable_type;
+			return jsonResult({
+				...formatted,
+				_hints: getAttachmentHints(id, attachableType)
+			});
+		}
+		return jsonResult(formatted);
+	}
+	if (action === "delete") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("delete"));
+		await deleteAttachment({ id }, execCtx);
+		return jsonResult({
+			success: true,
+			deleted: id
+		});
+	}
+	if (action === "list") {
+		const options = { ...filter };
+		if (task_id) options.task_id = task_id;
+		if (comment_id) options.comment_id = comment_id;
+		if (deal_id) options.deal_id = deal_id;
+		const result = await listAttachments({
+			page,
+			perPage,
+			additionalFilters: options
+		}, execCtx);
+		return jsonResult(formatListResponse$1(result.data, formatAttachment$1, result.meta, formatOptions));
+	}
+	return inputErrorResult(ErrorMessages.invalidAction(action, "attachments", VALID_ACTIONS$14));
+}
+/**
+* Bookings MCP handler.
+*/
+var VALID_ACTIONS$13 = [
+	"list",
+	"get",
+	"create",
+	"update"
+];
+async function handleBookings(action, args, ctx) {
+	const { formatOptions, filter, page, perPage, include: userInclude } = ctx;
+	const { id, person_id, service_id, event_id, started_on, ended_on, time, note } = args;
+	const include = userInclude?.length ? [...new Set([
+		"person",
+		"service",
+		...userInclude
+	])] : ["person", "service"];
+	const execCtx = ctx.executor();
+	if (action === "get") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+		const result = await getBooking({
+			id,
+			include
+		}, execCtx);
+		const formatted = formatBooking$1(result.data, {
+			...formatOptions,
+			included: result.included
+		});
+		if (ctx.includeHints !== false) {
+			const personId = result.data.relationships?.person?.data?.id;
+			return jsonResult({
+				...formatted,
+				_hints: getBookingHints(id, personId)
+			});
+		}
+		return jsonResult(formatted);
+	}
+	if (action === "create") {
+		if (!person_id || !started_on || !ended_on) return inputErrorResult(ErrorMessages.missingRequiredFields("booking", [
+			"person_id",
+			"started_on",
+			"ended_on"
+		]));
+		if (!service_id && !event_id) return inputErrorResult(ErrorMessages.missingBookingTarget());
+		return jsonResult({
+			success: true,
+			...formatBooking$1((await createBooking({
+				personId: person_id,
+				serviceId: service_id ?? "",
+				startedOn: started_on,
+				endedOn: ended_on,
+				time,
+				note,
+				eventId: event_id
+			}, execCtx)).data, formatOptions)
+		});
+	}
+	if (action === "update") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("update"));
+		return jsonResult({
+			success: true,
+			...formatBooking$1((await updateBooking({
+				id,
+				startedOn: started_on,
+				endedOn: ended_on,
+				time,
+				note
+			}, execCtx)).data, formatOptions)
+		});
+	}
+	if (action === "list") {
+		const result = await listBookings({
+			page,
+			perPage,
+			additionalFilters: filter,
+			include
+		}, execCtx);
+		return jsonResult(formatListResponse$1(result.data, formatBooking$1, result.meta, formatOptions));
+	}
+	return inputErrorResult(ErrorMessages.invalidAction(action, "bookings", VALID_ACTIONS$13));
+}
+/**
+* Budgets MCP handler.
+*
+* Thin adapter that delegates business logic to core executors
+* and handles MCP-specific concerns (hints, error formatting, JSON results).
+*/
+var VALID_ACTIONS$12 = ["list", "get"];
+async function handleBudgets(action, args, ctx) {
+	const { formatOptions, filter, page, perPage } = ctx;
+	const { id } = args;
+	const execCtx = ctx.executor();
+	if (action === "get") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+		const formatted = formatBudget$1((await getBudget({ id }, execCtx)).data, formatOptions);
+		if (ctx.includeHints !== false) return jsonResult({
+			...formatted,
+			_hints: getBudgetHints(id)
+		});
+		return jsonResult(formatted);
+	}
+	if (action === "list") {
+		const result = await listBudgets({
+			page,
+			perPage,
+			additionalFilters: filter
+		}, execCtx);
+		return jsonResult(formatListResponse$1(result.data, formatBudget$1, result.meta, formatOptions));
+	}
+	return inputErrorResult(ErrorMessages.invalidAction(action, "budgets", VALID_ACTIONS$12));
+}
+/**
+* Comments MCP handler.
+*/
+var VALID_ACTIONS$11 = [
+	"list",
+	"get",
+	"create",
+	"update"
+];
+async function handleComments(action, args, ctx) {
+	const { formatOptions, filter, page, perPage, include: userInclude } = ctx;
+	const { id, body, task_id, deal_id, company_id } = args;
+	const include = userInclude?.length ? [...new Set(["creator", ...userInclude])] : ["creator"];
+	const execCtx = ctx.executor();
+	if (action === "get") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+		const result = await getComment({
+			id,
+			include
+		}, execCtx);
+		const formatted = formatComment$1(result.data, {
+			...formatOptions,
+			included: result.included
+		});
+		if (ctx.includeHints !== false) {
+			const commentableType = result.data.attributes?.commentable_type;
+			let commentableId;
+			if (commentableType === "task") commentableId = result.data.relationships?.task?.data?.id;
+			else if (commentableType === "deal") commentableId = result.data.relationships?.deal?.data?.id;
+			else if (commentableType === "company") commentableId = result.data.relationships?.company?.data?.id;
+			return jsonResult({
+				...formatted,
+				_hints: getCommentHints(id, commentableType, commentableId)
+			});
+		}
+		return jsonResult(formatted);
+	}
+	if (action === "create") {
+		if (!body) return inputErrorResult(ErrorMessages.missingRequiredFields("comment", ["body"]));
+		if (!task_id && !deal_id && !company_id) return inputErrorResult(ErrorMessages.missingCommentTarget());
+		return jsonResult({
+			success: true,
+			...formatComment$1((await createComment({
+				body,
+				taskId: task_id,
+				dealId: deal_id,
+				companyId: company_id
+			}, execCtx)).data, formatOptions)
+		});
+	}
+	if (action === "update") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("update"));
+		if (!body) return inputErrorResult(ErrorMessages.missingRequiredFields("comment update", ["body"]));
+		return jsonResult({
+			success: true,
+			...formatComment$1((await updateComment({
+				id,
+				body
+			}, execCtx)).data, formatOptions)
+		});
+	}
+	if (action === "list") {
+		const result = await listComments({
+			page,
+			perPage,
+			additionalFilters: filter,
+			include
+		}, execCtx);
+		return jsonResult(formatListResponse$1(result.data, formatComment$1, result.meta, formatOptions));
+	}
+	return inputErrorResult(ErrorMessages.invalidAction(action, "comments", VALID_ACTIONS$11));
+}
+/**
+* Resolve handler for MCP.
+*
+* Thin wrapper around core's resource resolver.
+* Provides handleResolve for the MCP 'resolve' action.
+*/
+/**
+* Handle resolve action for a resource.
+*
+* Delegates to core's resolveResource function and wraps
+* errors in MCP-friendly format.
+*/
+async function handleResolve(args, ctx) {
+	const { query, type, project_id } = args;
+	if (!query) return errorResult("query is required for resolve action");
+	try {
+		const results = await resolveResource(ctx.executor().api, query, {
+			type,
+			projectId: project_id
+		});
+		return jsonResult({
+			query,
+			matches: results,
+			exact: results.length === 1 && results[0].exact
+		});
+	} catch (error) {
+		if (error instanceof ResolveError) return inputErrorResult(new UserInputError(error.message, [`Query: "${error.query}"`, ...error.type ? [`Type: ${error.type}`] : []]));
+		throw error;
+	}
+}
+/**
+* Companies MCP handler.
+*/
+var VALID_ACTIONS$10 = [
+	"list",
+	"get",
+	"create",
+	"update",
+	"resolve"
+];
+async function handleCompanies(action, args, ctx) {
+	const { formatOptions, filter, page, perPage } = ctx;
+	const { id, name, query, type } = args;
+	if (action === "resolve") return handleResolve({
+		query,
+		type
+	}, ctx);
+	const execCtx = ctx.executor();
+	if (action === "get") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+		const formatted = formatCompany$1((await getCompany({ id }, execCtx)).data, formatOptions);
+		if (ctx.includeHints !== false) return jsonResult({
+			...formatted,
+			_hints: getCompanyHints(id)
+		});
+		return jsonResult(formatted);
+	}
+	if (action === "create") {
+		if (!name) return inputErrorResult(ErrorMessages.missingRequiredFields("company", ["name"]));
+		return jsonResult({
+			success: true,
+			...formatCompany$1((await createCompany({ name }, execCtx)).data, formatOptions)
+		});
+	}
+	if (action === "update") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("update"));
+		return jsonResult({
+			success: true,
+			...formatCompany$1((await updateCompany({
+				id,
+				name
+			}, execCtx)).data, formatOptions)
+		});
+	}
+	if (action === "list") {
+		const result = await listCompanies({
+			page,
+			perPage,
+			additionalFilters: filter
+		}, execCtx);
+		const response = formatListResponse$1(result.data, formatCompany$1, result.meta, formatOptions);
+		if (result.resolved && Object.keys(result.resolved).length > 0) return jsonResult({
+			...response,
+			_resolved: result.resolved
+		});
+		return jsonResult(response);
+	}
+	return inputErrorResult(ErrorMessages.invalidAction(action, "companies", VALID_ACTIONS$10));
+}
+/**
+* Deals MCP handler.
+*/
+var VALID_ACTIONS$9 = [
+	"list",
+	"get",
+	"create",
+	"update",
+	"resolve"
+];
+async function handleDeals(action, args, ctx) {
+	const { formatOptions, filter, page, perPage, include: userInclude } = ctx;
+	const { id, name, company_id, query, type } = args;
+	if (action === "resolve") return handleResolve({
+		query,
+		type
+	}, ctx);
+	const execCtx = ctx.executor();
+	if (action === "get") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+		const result = await getDeal({
+			id,
+			include: userInclude?.length ? [...new Set([
+				"company",
+				"deal_status",
+				"responsible",
+				...userInclude
+			])] : [
+				"company",
+				"deal_status",
+				"responsible"
+			]
+		}, execCtx);
+		const formatted = formatDeal$1(result.data, {
+			...formatOptions,
+			included: result.included
+		});
+		if (ctx.includeHints !== false) return jsonResult({
+			...formatted,
+			_hints: getDealHints(id)
+		});
+		return jsonResult(formatted);
+	}
+	if (action === "create") {
+		if (!name || !company_id) return inputErrorResult(ErrorMessages.missingRequiredFields("deal", ["name", "company_id"]));
+		return jsonResult({
+			success: true,
+			...formatDeal$1((await createDeal({
+				name,
+				companyId: company_id
+			}, execCtx)).data, formatOptions)
+		});
+	}
+	if (action === "update") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("update"));
+		return jsonResult({
+			success: true,
+			...formatDeal$1((await updateDeal({
+				id,
+				name
+			}, execCtx)).data, formatOptions)
+		});
+	}
+	if (action === "list") {
+		const result = await listDeals({
+			page,
+			perPage,
+			additionalFilters: filter,
+			include: userInclude?.length ? [...new Set([
+				"company",
+				"deal_status",
+				...userInclude
+			])] : ["company", "deal_status"]
+		}, execCtx);
+		const response = formatListResponse$1(result.data, formatDeal$1, result.meta, {
+			...formatOptions,
+			included: result.included
+		});
+		if (result.resolved && Object.keys(result.resolved).length > 0) return jsonResult({
+			...response,
+			_resolved: result.resolved
+		});
+		return jsonResult(response);
+	}
+	return inputErrorResult(ErrorMessages.invalidAction(action, "deals", VALID_ACTIONS$9));
+}
+/**
+* Discussions MCP handler.
+*/
+var VALID_ACTIONS$8 = [
+	"list",
+	"get",
+	"create",
+	"update",
+	"delete",
+	"resolve",
+	"reopen"
+];
+async function handleDiscussions(action, args, ctx) {
+	const { formatOptions, filter, page, perPage } = ctx;
+	const { id, title, body, page_id, status } = args;
+	const execCtx = ctx.executor();
+	if (action === "get") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+		const formatted = formatDiscussion$1((await getDiscussion({ id }, execCtx)).data, formatOptions);
+		if (ctx.includeHints !== false) return jsonResult({
+			...formatted,
+			_hints: getDiscussionHints(id, page_id)
+		});
+		return jsonResult(formatted);
+	}
+	if (action === "create") {
+		if (!body || !page_id) return inputErrorResult(ErrorMessages.missingRequiredFields("discussion", ["body", "page_id"]));
+		return jsonResult({
+			success: true,
+			...formatDiscussion$1((await createDiscussion({
+				body,
+				pageId: page_id,
+				title
+			}, execCtx)).data, formatOptions)
+		});
+	}
+	if (action === "update") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("update"));
+		return jsonResult({
+			success: true,
+			...formatDiscussion$1((await updateDiscussion({
+				id,
+				title,
+				body
+			}, execCtx)).data, formatOptions)
+		});
+	}
+	if (action === "delete") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("delete"));
+		await deleteDiscussion({ id }, execCtx);
+		return jsonResult({
+			success: true,
+			deleted: id
+		});
+	}
+	if (action === "resolve") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("resolve"));
+		return jsonResult({
+			success: true,
+			...formatDiscussion$1((await resolveDiscussion({ id }, execCtx)).data, formatOptions)
+		});
+	}
+	if (action === "reopen") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("reopen"));
+		return jsonResult({
+			success: true,
+			...formatDiscussion$1((await reopenDiscussion({ id }, execCtx)).data, formatOptions)
+		});
+	}
+	if (action === "list") {
+		const listOptions = {
+			page,
+			perPage,
+			additionalFilters: filter
+		};
+		if (status) listOptions.status = status;
+		const result = await listDiscussions(listOptions, execCtx);
+		const response = formatListResponse$1(result.data, formatDiscussion$1, result.meta, formatOptions);
+		if (result.resolved && Object.keys(result.resolved).length > 0) return jsonResult({
+			...response,
+			_resolved: result.resolved
+		});
+		return jsonResult(response);
+	}
+	return inputErrorResult(ErrorMessages.invalidAction(action, "discussions", VALID_ACTIONS$8));
+}
+var RESOURCE_HELP = {
+	projects: {
+		description: "Manage projects in Productive.io",
+		actions: {
+			list: "List all projects with optional filters",
+			get: "Get a single project by ID with full details"
+		},
+		filters: {
+			query: "Text search on project name",
+			project_type: "Filter by project type: 1=internal, 2=client",
+			company_id: "Filter by company",
+			responsible_id: "Filter by project manager",
+			person_id: "Filter by team member",
+			status: "Filter by status: 1=active, 2=archived"
+		},
+		fields: {
+			id: "Unique project identifier",
+			name: "Project name",
+			project_number: "Project reference number",
+			archived: "Whether the project is archived",
+			budget: "Project budget amount"
+		},
+		examples: [
+			{
+				description: "Search projects by name",
+				params: {
+					resource: "projects",
+					action: "list",
+					query: "website"
+				}
+			},
+			{
+				description: "List active projects",
+				params: {
+					resource: "projects",
+					action: "list",
+					filter: { archived: "false" }
+				}
+			},
+			{
+				description: "Get project details",
+				params: {
+					resource: "projects",
+					action: "get",
+					id: "12345"
+				}
+			}
+		]
+	},
+	tasks: {
+		description: "Manage tasks within projects",
+		actions: {
+			list: "List tasks with optional filters",
+			get: "Get a single task by ID with full details (description, comments, etc.)",
+			create: "Create a new task (requires title, project_id, task_list_id)",
+			update: "Update an existing task"
+		},
+		filters: {
+			query: "Text search on task title",
+			project_id: "Filter by project",
+			company_id: "Filter by company",
+			assignee_id: "Filter by assigned person",
+			creator_id: "Filter by task creator",
+			status: "Filter by status: 1=open, 2=closed (or \"open\", \"closed\", \"all\")",
+			task_list_id: "Filter by task list",
+			board_id: "Filter by board",
+			workflow_status_id: "Filter by workflow status (kanban column)",
+			parent_task_id: "Filter by parent task (for subtasks)",
+			overdue_status: "Filter by overdue: 1=not overdue, 2=overdue",
+			due_date_on: "Filter by exact due date (YYYY-MM-DD)",
+			due_date_before: "Filter by due date before (YYYY-MM-DD)",
+			due_date_after: "Filter by due date after (YYYY-MM-DD)"
+		},
+		includes: [
+			"project",
+			"project.company",
+			"assignee",
+			"workflow_status",
+			"comments",
+			"attachments",
+			"subtasks"
+		],
+		fields: {
+			id: "Unique task identifier",
+			title: "Task title",
+			description: "Full task description (HTML)",
+			number: "Task number within project",
+			due_date: "Due date (YYYY-MM-DD)",
+			initial_estimate: "Estimated time in minutes",
+			worked_time: "Logged time in minutes",
+			remaining_time: "Remaining time in minutes",
+			closed: "Whether the task is closed"
+		},
+		examples: [
+			{
+				description: "Search tasks by title",
+				params: {
+					resource: "tasks",
+					action: "list",
+					query: "bug fix"
+				}
+			},
+			{
+				description: "List open tasks for a project",
+				params: {
+					resource: "tasks",
+					action: "list",
+					filter: {
+						project_id: "12345",
+						status: "open"
+					}
+				}
+			},
+			{
+				description: "Get task with comments",
+				params: {
+					resource: "tasks",
+					action: "get",
+					id: "67890",
+					include: ["comments", "assignee"]
+				}
+			},
+			{
+				description: "Create a task",
+				params: {
+					resource: "tasks",
+					action: "create",
+					title: "New task",
+					project_id: "12345",
+					task_list_id: "111"
+				}
+			}
+		]
+	},
+	time: {
+		description: "Track time entries against services/tasks",
+		actions: {
+			list: "List time entries with optional filters",
+			get: "Get a single time entry by ID",
+			create: "Create a new time entry (requires person_id, service_id, date, time)",
+			update: "Update an existing time entry"
+		},
+		filters: {
+			person_id: "Filter by person (use \"me\" for current user)",
+			service_id: "Filter by service",
+			project_id: "Filter by project",
+			task_id: "Filter by task",
+			company_id: "Filter by company",
+			deal_id: "Filter by deal",
+			budget_id: "Filter by budget",
+			after: "Filter entries after date (YYYY-MM-DD)",
+			before: "Filter entries before date (YYYY-MM-DD)",
+			status: "Filter by approval status: 1=approved, 2=unapproved, 3=rejected",
+			billing_type_id: "Filter by billing type: 1=fixed, 2=actuals, 3=non_billable",
+			invoicing_status: "Filter by invoicing: 1=not_invoiced, 2=drafted, 3=finalized"
+		},
+		fields: {
+			id: "Unique time entry identifier",
+			date: "Date of the entry (YYYY-MM-DD)",
+			time: "Time in minutes",
+			note: "Description of work done",
+			billable_time: "Billable time in minutes",
+			approved: "Whether the entry is approved"
+		},
+		examples: [{
+			description: "List my time entries this week",
+			params: {
+				resource: "time",
+				action: "list",
+				filter: {
+					person_id: "me",
+					after: "2024-01-15",
+					before: "2024-01-21"
+				}
+			}
+		}, {
+			description: "Log 2 hours",
+			params: {
+				resource: "time",
+				action: "create",
+				service_id: "12345",
+				date: "2024-01-16",
+				time: 120,
+				note: "Development work"
+			}
+		}]
+	},
+	services: {
+		description: "Budget line items within projects",
+		actions: {
+			list: "List services with optional filters",
+			get: "Get a single service by ID"
+		},
+		filters: {
+			project_id: "Filter by project",
+			deal_id: "Filter by deal",
+			task_id: "Filter by task",
+			person_id: "Filter by person (trackable by)",
+			budget_status: "Filter by budget status: 1=open, 2=delivered",
+			billing_type: "Filter by billing type: 1=fixed, 2=actuals, 3=none",
+			time_tracking_enabled: "Filter by time tracking: true/false"
+		},
+		fields: {
+			id: "Unique service identifier",
+			name: "Service name",
+			budgeted_time: "Budgeted time in minutes",
+			worked_time: "Logged time in minutes"
+		},
+		examples: [{
+			description: "List services for a project",
+			params: {
+				resource: "services",
+				action: "list",
+				filter: { project_id: "12345" }
+			}
+		}]
+	},
+	people: {
+		description: "Team members and contacts",
+		actions: {
+			list: "List people with optional filters",
+			get: "Get a single person by ID",
+			me: "Get the currently authenticated user"
+		},
+		filters: {
+			query: "Text search on name or email",
+			status: "Filter by status: 1=active, 2=deactivated",
+			person_type: "Filter by type: 1=user, 2=contact, 3=placeholder",
+			company_id: "Filter by company",
+			project_id: "Filter by project",
+			role_id: "Filter by role",
+			team: "Filter by team name"
+		},
+		fields: {
+			id: "Unique person identifier",
+			name: "Full name",
+			first_name: "First name",
+			last_name: "Last name",
+			email: "Email address",
+			title: "Job title",
+			active: "Whether the person is active"
+		},
+		examples: [
+			{
+				description: "Get current user",
+				params: {
+					resource: "people",
+					action: "me"
+				}
+			},
+			{
+				description: "Search people by name",
+				params: {
+					resource: "people",
+					action: "list",
+					query: "john"
+				}
+			},
+			{
+				description: "List active team members",
+				params: {
+					resource: "people",
+					action: "list",
+					filter: { status: "active" }
+				}
+			}
+		]
+	},
+	companies: {
+		description: "Client companies and organizations",
+		actions: {
+			list: "List companies with optional filters",
+			get: "Get a single company by ID",
+			create: "Create a new company (requires name)",
+			update: "Update an existing company"
+		},
+		filters: {
+			query: "Text search on company name",
+			archived: "Filter by archived status (true/false)"
+		},
+		fields: {
+			id: "Unique company identifier",
+			name: "Company name",
+			billing_name: "Legal/billing name",
+			domain: "Website domain",
+			vat: "VAT number"
+		},
+		examples: [{
+			description: "Search companies",
+			params: {
+				resource: "companies",
+				action: "list",
+				query: "acme"
+			}
+		}, {
+			description: "List active companies",
+			params: {
+				resource: "companies",
+				action: "list",
+				filter: { archived: "false" }
+			}
+		}]
+	},
+	attachments: {
+		description: "File attachments on tasks, comments, deals, and pages",
+		actions: {
+			list: "List attachments with optional filters",
+			get: "Get a single attachment by ID",
+			delete: "Delete an attachment by ID"
+		},
+		filters: {
+			task_id: "Filter by task",
+			comment_id: "Filter by comment",
+			deal_id: "Filter by deal",
+			page_id: "Filter by page"
+		},
+		fields: {
+			id: "Unique attachment identifier",
+			name: "File name",
+			content_type: "MIME type (e.g., image/png, application/pdf)",
+			size: "File size in bytes",
+			size_human: "Human-readable file size (e.g., 1.5 MB)",
+			url: "Download URL",
+			attachable_type: "Parent resource type (Task, Comment, Deal, Page)"
+		},
+		examples: [
+			{
+				description: "List attachments on a task",
+				params: {
+					resource: "attachments",
+					action: "list",
+					filter: { task_id: "12345" }
+				}
+			},
+			{
+				description: "Get attachment details",
+				params: {
+					resource: "attachments",
+					action: "get",
+					id: "67890"
+				}
+			},
+			{
+				description: "Delete an attachment",
+				params: {
+					resource: "attachments",
+					action: "delete",
+					id: "67890"
+				}
+			}
+		]
+	},
+	comments: {
+		description: "Comments on tasks, deals, and other resources",
+		actions: {
+			list: "List comments with optional filters",
+			get: "Get a single comment by ID",
+			create: "Create a new comment (requires body and one of: task_id, deal_id, company_id)",
+			update: "Update an existing comment"
+		},
+		filters: {
+			task_id: "Filter by task",
+			deal_id: "Filter by deal",
+			project_id: "Filter by project",
+			page_id: "Filter by page",
+			discussion_id: "Filter by discussion"
+		},
+		includes: [
+			"creator",
+			"task",
+			"deal"
+		],
+		fields: {
+			id: "Unique comment identifier",
+			body: "Comment text (may contain HTML)",
+			creator: "Person who created the comment"
+		},
+		examples: [{
+			description: "List comments on a task",
+			params: {
+				resource: "comments",
+				action: "list",
+				filter: { task_id: "12345" }
+			}
+		}, {
+			description: "Add a comment",
+			params: {
+				resource: "comments",
+				action: "create",
+				task_id: "12345",
+				body: "Looking good!"
+			}
+		}]
+	},
+	timers: {
+		description: "Active time tracking timers",
+		actions: {
+			list: "List active timers",
+			get: "Get a single timer by ID",
+			start: "Start a new timer (requires service_id or time_entry_id)",
+			stop: "Stop an active timer by ID"
+		},
+		filters: {
+			person_id: "Filter by person",
+			time_entry_id: "Filter by time entry"
+		},
+		fields: {
+			id: "Unique timer identifier",
+			started_at: "When the timer started (ISO 8601)",
+			total_time: "Elapsed time in seconds"
+		},
+		examples: [
+			{
+				description: "List active timers",
+				params: {
+					resource: "timers",
+					action: "list"
+				}
+			},
+			{
+				description: "Start timer on service",
+				params: {
+					resource: "timers",
+					action: "start",
+					service_id: "12345"
+				}
+			},
+			{
+				description: "Stop timer",
+				params: {
+					resource: "timers",
+					action: "stop",
+					id: "67890"
+				}
+			}
+		]
+	},
+	deals: {
+		description: "Sales deals and opportunities",
+		actions: {
+			list: "List deals with optional filters",
+			get: "Get a single deal by ID",
+			create: "Create a new deal (requires name, company_id)",
+			update: "Update an existing deal"
+		},
+		filters: {
+			query: "Text search on deal name",
+			company_id: "Filter by company",
+			project_id: "Filter by project",
+			responsible_id: "Filter by responsible person",
+			pipeline_id: "Filter by pipeline",
+			stage_status_id: "Filter by stage: 1=open, 2=won, 3=lost",
+			type: "Filter by type: 1=deal, 2=budget",
+			budget_status: "Filter by budget status: 1=open, 2=closed"
+		},
+		includes: [
+			"company",
+			"deal_status",
+			"responsible",
+			"project"
+		],
+		fields: {
+			id: "Unique deal identifier",
+			name: "Deal name",
+			number: "Deal number",
+			date: "Deal date",
+			status: "Current status (from deal_status)"
+		},
+		examples: [{
+			description: "Search deals",
+			params: {
+				resource: "deals",
+				action: "list",
+				query: "website redesign"
+			}
+		}, {
+			description: "List deals for a company",
+			params: {
+				resource: "deals",
+				action: "list",
+				filter: { company_id: "12345" }
+			}
+		}]
+	},
+	bookings: {
+		description: "Resource scheduling and capacity planning",
+		actions: {
+			list: "List bookings with optional filters",
+			get: "Get a single booking by ID",
+			create: "Create a new booking (requires person_id, started_on, ended_on, and service_id or event_id)",
+			update: "Update an existing booking"
+		},
+		filters: {
+			person_id: "Filter by person",
+			service_id: "Filter by service",
+			project_id: "Filter by project",
+			company_id: "Filter by company",
+			event_id: "Filter by event",
+			after: "Filter bookings after date (YYYY-MM-DD)",
+			before: "Filter bookings before date (YYYY-MM-DD)",
+			booking_type: "Filter by type: event (absence) or service (budget)",
+			draft: "Filter by tentative status: true/false"
+		},
+		includes: [
+			"person",
+			"service",
+			"event"
+		],
+		fields: {
+			id: "Unique booking identifier",
+			started_on: "Start date (YYYY-MM-DD)",
+			ended_on: "End date (YYYY-MM-DD)",
+			time: "Time per day in minutes",
+			total_time: "Total booked time in minutes",
+			note: "Booking note"
+		},
+		examples: [{
+			description: "List my bookings",
+			params: {
+				resource: "bookings",
+				action: "list",
+				filter: { person_id: "me" }
+			}
+		}]
+	},
+	budgets: {
+		description: "Budget tracking and financial overview",
+		actions: {
+			list: "List budgets with optional filters",
+			get: "Get a single budget by ID with full details"
+		},
+		filters: {
+			project_id: "Filter by project",
+			company_id: "Filter by company",
+			deal_id: "Filter by deal",
+			billable: "Filter by billable status (true/false)",
+			budget_type: "Filter by budget type"
+		},
+		fields: {
+			id: "Unique budget identifier",
+			name: "Budget name",
+			budget_type: "Type of budget",
+			billable: "Whether the budget is billable",
+			started_on: "Budget start date (YYYY-MM-DD)",
+			ended_on: "Budget end date (YYYY-MM-DD)",
+			currency: "Budget currency code",
+			total_time_budget: "Total time budget in minutes",
+			remaining_time_budget: "Remaining time budget in minutes",
+			total_monetary_budget: "Total monetary budget",
+			remaining_monetary_budget: "Remaining monetary budget"
+		},
+		examples: [
+			{
+				description: "List all budgets",
+				params: {
+					resource: "budgets",
+					action: "list"
+				}
+			},
+			{
+				description: "List budgets for a project",
+				params: {
+					resource: "budgets",
+					action: "list",
+					filter: { project_id: "12345" }
+				}
+			},
+			{
+				description: "Get budget details",
+				params: {
+					resource: "budgets",
+					action: "get",
+					id: "67890"
+				}
+			},
+			{
+				description: "List billable budgets",
+				params: {
+					resource: "budgets",
+					action: "list",
+					filter: { billable: "true" }
+				}
+			}
+		]
+	},
+	pages: {
+		description: "Manage pages (wiki/docs) within projects",
+		actions: {
+			list: "List pages with optional filters",
+			get: "Get a single page by ID with full details",
+			create: "Create a new page (requires title, project_id)",
+			update: "Update an existing page",
+			delete: "Delete a page"
+		},
+		filters: {
+			project_id: "Filter by project",
+			creator_id: "Filter by creator",
+			parent_page_id: "Filter by parent page (for sub-pages)"
+		},
+		fields: {
+			id: "Unique page identifier",
+			title: "Page title",
+			body: "Page body content (HTML)",
+			public: "Whether the page is publicly accessible",
+			version_number: "Current version number",
+			parent_page_id: "Parent page ID (for sub-pages)"
+		},
+		examples: [
+			{
+				description: "List pages for a project",
+				params: {
+					resource: "pages",
+					action: "list",
+					filter: { project_id: "12345" }
+				}
+			},
+			{
+				description: "Get page details",
+				params: {
+					resource: "pages",
+					action: "get",
+					id: "67890"
+				}
+			},
+			{
+				description: "Create a page",
+				params: {
+					resource: "pages",
+					action: "create",
+					title: "Getting Started",
+					project_id: "12345"
+				}
+			},
+			{
+				description: "Create a sub-page",
+				params: {
+					resource: "pages",
+					action: "create",
+					title: "Sub-section",
+					project_id: "12345",
+					parent_page_id: "67890"
+				}
+			},
+			{
+				description: "Delete a page",
+				params: {
+					resource: "pages",
+					action: "delete",
+					id: "67890"
+				}
+			}
+		]
+	},
+	discussions: {
+		description: "Manage discussions (comment threads on highlighted page content)",
+		actions: {
+			list: "List discussions with optional filters",
+			get: "Get a single discussion by ID",
+			create: "Create a new discussion (requires body, page_id)",
+			update: "Update an existing discussion",
+			delete: "Delete a discussion",
+			resolve: "Resolve a discussion (mark as resolved)",
+			reopen: "Reopen a resolved discussion"
+		},
+		filters: {
+			page_id: "Filter by page",
+			status: "Filter by status: 1=active, 2=resolved"
+		},
+		fields: {
+			id: "Unique discussion identifier",
+			title: "Discussion title",
+			body: "Discussion body (HTML)",
+			status: "Status: active or resolved",
+			resolved_at: "When the discussion was resolved"
+		},
+		examples: [
+			{
+				description: "List discussions on a page",
+				params: {
+					resource: "discussions",
+					action: "list",
+					filter: { page_id: "12345" }
+				}
+			},
+			{
+				description: "List active discussions",
+				params: {
+					resource: "discussions",
+					action: "list",
+					status: "active"
+				}
+			},
+			{
+				description: "Create a discussion",
+				params: {
+					resource: "discussions",
+					action: "create",
+					page_id: "12345",
+					body: "Review this section"
+				}
+			},
+			{
+				description: "Resolve a discussion",
+				params: {
+					resource: "discussions",
+					action: "resolve",
+					id: "67890"
+				}
+			},
+			{
+				description: "Reopen a discussion",
+				params: {
+					resource: "discussions",
+					action: "reopen",
+					id: "67890"
+				}
+			}
+		]
+	},
+	reports: {
+		description: "Generate various reports (time, budget, project, etc.)",
+		actions: { get: "Generate a report (requires report_type)" },
+		filters: {
+			person_id: "Filter by person",
+			project_id: "Filter by project",
+			company_id: "Filter by company",
+			after: "Filter from date (YYYY-MM-DD)",
+			before: "Filter to date (YYYY-MM-DD)"
+		},
+		fields: {
+			report_type: "Type of report: time_reports, project_reports, budget_reports, person_reports, invoice_reports, payment_reports, service_reports, task_reports, company_reports, deal_reports, timesheet_reports",
+			group: "Grouping dimension (varies by report type)",
+			from: "Start date for date range",
+			to: "End date for date range"
+		},
+		examples: [{
+			description: "Time report by person",
+			params: {
+				resource: "reports",
+				action: "get",
+				report_type: "time_reports",
+				group: "person",
+				from: "2024-01-01",
+				to: "2024-01-31"
+			}
+		}, {
+			description: "Project budget report",
+			params: {
+				resource: "reports",
+				action: "get",
+				report_type: "budget_reports",
+				filter: { project_id: "12345" }
+			}
+		}]
+	}
+};
+/**
+* Handle help action - returns documentation for a specific resource
+*/
+function handleHelp(resource) {
+	const help = RESOURCE_HELP[resource];
+	if (!help) return jsonResult({
+		error: `Unknown resource: ${resource}`,
+		available_resources: Object.keys(RESOURCE_HELP)
+	});
+	return jsonResult({
+		resource,
+		...help
+	});
+}
+/**
+* Get help for all resources (overview)
+*/
+function handleHelpOverview() {
+	return jsonResult({
+		message: "Use action=\"help\" with a specific resource for detailed documentation",
+		resources: Object.entries(RESOURCE_HELP).map(([resource, help]) => ({
+			resource,
+			description: help.description,
+			actions: Object.keys(help.actions)
+		}))
+	});
+}
+/**
+* Pages MCP handler.
+*/
+var VALID_ACTIONS$7 = [
+	"list",
+	"get",
+	"create",
+	"update",
+	"delete"
+];
+async function handlePages(action, args, ctx) {
+	const { formatOptions, filter, page, perPage } = ctx;
+	const { id, title, body, project_id, parent_page_id } = args;
+	const execCtx = ctx.executor();
+	if (action === "get") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+		const formatted = formatPage$1((await getPage({ id }, execCtx)).data, formatOptions);
+		if (ctx.includeHints !== false) return jsonResult({
+			...formatted,
+			_hints: getPageHints(id)
+		});
+		return jsonResult(formatted);
+	}
+	if (action === "create") {
+		if (!title || !project_id) return inputErrorResult(ErrorMessages.missingRequiredFields("page", ["title", "project_id"]));
+		return jsonResult({
+			success: true,
+			...formatPage$1((await createPage({
+				title,
+				projectId: project_id,
+				body,
+				parentPageId: parent_page_id
+			}, execCtx)).data, formatOptions)
+		});
+	}
+	if (action === "update") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("update"));
+		return jsonResult({
+			success: true,
+			...formatPage$1((await updatePage({
+				id,
+				title,
+				body
+			}, execCtx)).data, formatOptions)
+		});
+	}
+	if (action === "delete") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("delete"));
+		await deletePage({ id }, execCtx);
+		return jsonResult({
+			success: true,
+			deleted: id
+		});
+	}
+	if (action === "list") {
+		const result = await listPages({
+			page,
+			perPage,
+			additionalFilters: filter
+		}, execCtx);
+		const response = formatListResponse$1(result.data, formatPage$1, result.meta, formatOptions);
+		if (result.resolved && Object.keys(result.resolved).length > 0) return jsonResult({
+			...response,
+			_resolved: result.resolved
+		});
+		return jsonResult(response);
+	}
+	return inputErrorResult(ErrorMessages.invalidAction(action, "pages", VALID_ACTIONS$7));
+}
+/**
+* People MCP handler.
+*/
+var VALID_ACTIONS$6 = [
+	"list",
+	"get",
+	"me",
+	"resolve"
+];
+async function handlePeople(action, args, ctx, credentials) {
+	const { formatOptions, filter, page, perPage } = ctx;
+	const { id, query, type } = args;
+	if (action === "resolve") return handleResolve({
+		query,
+		type
+	}, ctx);
+	const execCtx = ctx.executor();
+	if (action === "get") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+		const formatted = formatPerson$1((await getPerson({ id }, execCtx)).data, formatOptions);
+		if (ctx.includeHints !== false) return jsonResult({
+			...formatted,
+			_hints: getPersonHints(id)
+		});
+		return jsonResult(formatted);
+	}
+	if (action === "me") {
+		if (credentials.userId) {
+			const formatted = formatPerson$1((await getPerson({ id: credentials.userId }, execCtx)).data, formatOptions);
+			if (ctx.includeHints !== false) return jsonResult({
+				...formatted,
+				_hints: getPersonHints(credentials.userId)
+			});
+			return jsonResult(formatted);
+		}
+		return jsonResult({
+			message: "User ID not configured. Set userId in credentials to use this action.",
+			hint: "Use action=\"list\" to find people, or configure the user ID in your credentials.",
+			organizationId: credentials.organizationId
+		});
+	}
+	if (action === "list") {
+		const result = await listPeople({
+			page,
+			perPage,
+			additionalFilters: filter
+		}, execCtx);
+		const response = formatListResponse$1(result.data, formatPerson$1, result.meta, formatOptions);
+		if (result.resolved && Object.keys(result.resolved).length > 0) return jsonResult({
+			...response,
+			_resolved: result.resolved
+		});
+		return jsonResult(response);
+	}
+	return inputErrorResult(ErrorMessages.invalidAction(action, "people", VALID_ACTIONS$6));
+}
+/**
+* Projects MCP handler.
+*/
+var VALID_ACTIONS$5 = [
+	"list",
+	"get",
+	"resolve"
+];
+async function handleProjects(action, args, ctx) {
+	const { formatOptions, filter, page, perPage } = ctx;
+	const { id, query, type } = args;
+	if (action === "resolve") return handleResolve({
+		query,
+		type
+	}, ctx);
+	const execCtx = ctx.executor();
+	if (action === "get") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+		const formatted = formatProject$1((await getProject({ id }, execCtx)).data, formatOptions);
+		if (ctx.includeHints !== false) return jsonResult({
+			...formatted,
+			_hints: getProjectHints(id)
+		});
+		return jsonResult(formatted);
+	}
+	if (action === "list") {
+		const result = await listProjects({
+			page,
+			perPage,
+			additionalFilters: filter
+		}, execCtx);
+		const response = formatListResponse$1(result.data, formatProject$1, result.meta, formatOptions);
+		if (result.resolved && Object.keys(result.resolved).length > 0) return jsonResult({
+			...response,
+			_resolved: result.resolved
+		});
+		return jsonResult(response);
+	}
+	return inputErrorResult(ErrorMessages.invalidAction(action, "projects", VALID_ACTIONS$5));
+}
+/**
+* Reports MCP handler.
+*/
+function formatReportData(data) {
+	return data.map((item) => {
+		const record = item;
+		return {
+			id: record.id,
+			type: record.type,
+			...record.attributes
+		};
+	});
+}
+var VALID_ACTIONS$4 = ["get"];
+async function handleReports(action, args, ctx) {
+	const { filter, page, perPage } = ctx;
+	const { report_type, group, from, to, person_id, project_id, company_id, deal_id, status } = args;
+	if (action !== "get") return inputErrorResult(ErrorMessages.invalidAction(action, "reports", VALID_ACTIONS$4));
+	if (!report_type) return inputErrorResult(ErrorMessages.missingReportType());
+	if (!VALID_REPORT_TYPES.includes(report_type)) return inputErrorResult(ErrorMessages.invalidReportType(report_type, [...VALID_REPORT_TYPES]));
+	const execCtx = ctx.executor();
+	const result = await getReport({
+		reportType: report_type,
+		page,
+		perPage,
+		group,
+		from,
+		to,
+		personId: person_id,
+		projectId: project_id,
+		companyId: company_id,
+		dealId: deal_id,
+		status,
+		additionalFilters: filter
+	}, execCtx);
+	return jsonResult({
+		data: formatReportData(result.data),
+		meta: result.meta
+	});
+}
+/**
+* Services MCP handler.
+*/
+var VALID_ACTIONS$3 = ["list"];
+async function handleServices(action, _args, ctx) {
+	const { formatOptions, filter, page, perPage } = ctx;
+	if (action === "list") {
+		const execCtx = ctx.executor();
+		const result = await listServices({
+			page,
+			perPage,
+			additionalFilters: filter
+		}, execCtx);
+		return jsonResult(formatListResponse$1(result.data, formatService$1, result.meta, formatOptions));
+	}
+	return inputErrorResult(ErrorMessages.invalidAction(action, "services", VALID_ACTIONS$3));
+}
+/**
+* Tasks MCP handler.
+*/
+var DEFAULT_TASK_INCLUDE = ["project", "project.company"];
+var VALID_ACTIONS$2 = [
+	"list",
+	"get",
+	"create",
+	"update",
+	"resolve"
+];
+async function handleTasks(action, args, ctx) {
+	const { formatOptions, filter, page, perPage, include: userInclude } = ctx;
+	const { id, title, project_id, task_list_id, description, assignee_id, query, type } = args;
+	const include = userInclude?.length ? [...new Set([...DEFAULT_TASK_INCLUDE, ...userInclude])] : DEFAULT_TASK_INCLUDE;
+	if (action === "resolve") return handleResolve({
+		query,
+		type,
+		project_id
+	}, ctx);
+	const execCtx = ctx.executor();
+	if (action === "get") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+		const result = await getTask({
+			id,
+			include
+		}, execCtx);
+		const formatted = formatTask$1(result.data, {
+			...formatOptions,
+			included: result.included
+		});
+		if (ctx.includeHints !== false) {
+			const serviceId = result.data.relationships?.service?.data?.id;
+			return jsonResult({
+				...formatted,
+				_hints: getTaskHints(id, serviceId)
+			});
+		}
+		return jsonResult(formatted);
+	}
+	if (action === "create") {
+		if (!title || !project_id || !task_list_id) return inputErrorResult(ErrorMessages.missingRequiredFields("task", [
+			"title",
+			"project_id",
+			"task_list_id"
+		]));
+		return jsonResult({
+			success: true,
+			...formatTask$1((await createTask({
+				title,
+				projectId: project_id,
+				taskListId: task_list_id,
+				assigneeId: assignee_id,
+				description
+			}, execCtx)).data, formatOptions)
+		});
+	}
+	if (action === "update") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("update"));
+		return jsonResult({
+			success: true,
+			...formatTask$1((await updateTask({
+				id,
+				title,
+				description,
+				assigneeId: assignee_id
+			}, execCtx)).data, formatOptions)
+		});
+	}
+	if (action === "list") {
+		const result = await listTasks({
+			page,
+			perPage,
+			additionalFilters: filter,
+			include
+		}, execCtx);
+		const response = formatListResponse$1(result.data, formatTask$1, result.meta, {
+			...formatOptions,
+			included: result.included
+		});
+		if (result.resolved && Object.keys(result.resolved).length > 0) return jsonResult({
+			...response,
+			_resolved: result.resolved
+		});
+		return jsonResult(response);
+	}
+	return inputErrorResult(ErrorMessages.invalidAction(action, "tasks", VALID_ACTIONS$2));
+}
+/**
+* Time entries MCP handler.
+*
+* Thin adapter that delegates business logic to core executors
+* and handles MCP-specific concerns (hints, error formatting, JSON results).
+*/
+var VALID_ACTIONS$1 = [
+	"list",
+	"get",
+	"create",
+	"update",
+	"resolve"
+];
+async function handleTime(action, args, ctx) {
+	const { formatOptions, filter, page, perPage } = ctx;
+	const { id, person_id, service_id, task_id, time, date, note, query, type, project_id } = args;
+	if (action === "resolve") return handleResolve({
+		query,
+		type,
+		project_id
+	}, ctx);
+	const execCtx = ctx.executor();
+	if (action === "get") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+		const result = await getTimeEntry({ id }, execCtx);
+		const formatted = formatTimeEntry$1(result.data, formatOptions);
+		if (ctx.includeHints !== false) {
+			const serviceId = result.data.relationships?.service?.data?.id;
+			return jsonResult({
+				...formatted,
+				_hints: getTimeEntryHints(id, void 0, serviceId)
+			});
+		}
+		return jsonResult(formatted);
+	}
+	if (action === "create") {
+		if (!person_id || !service_id || !time || !date) return inputErrorResult(ErrorMessages.missingRequiredFields("time entry", [
+			"person_id",
+			"service_id",
+			"time",
+			"date"
+		]));
+		return jsonResult({
+			success: true,
+			...formatTimeEntry$1((await createTimeEntry({
+				personId: person_id,
+				serviceId: service_id,
+				time,
+				date,
+				note: note ?? void 0,
+				taskId: task_id,
+				projectId: project_id
+			}, execCtx)).data, formatOptions)
+		});
+	}
+	if (action === "update") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("update"));
+		return jsonResult({
+			success: true,
+			...formatTimeEntry$1((await updateTimeEntry({
+				id,
+				time: time ?? void 0,
+				date: date ?? void 0,
+				note: note ?? void 0
+			}, execCtx)).data, formatOptions)
+		});
+	}
+	if (action === "list") {
+		const result = await listTimeEntries({
+			page,
+			perPage,
+			additionalFilters: filter
+		}, execCtx);
+		const response = formatListResponse$1(result.data, formatTimeEntry$1, result.meta, formatOptions);
+		if (result.resolved && Object.keys(result.resolved).length > 0) return jsonResult({
+			...response,
+			_resolved: result.resolved
+		});
+		return jsonResult(response);
+	}
+	return inputErrorResult(ErrorMessages.invalidAction(action, "time", VALID_ACTIONS$1));
+}
+/**
+* Timers MCP handler.
+*/
+var VALID_ACTIONS = [
+	"list",
+	"get",
+	"start",
+	"stop"
+];
+async function handleTimers(action, args, ctx) {
+	const { formatOptions, filter, page, perPage, include } = ctx;
+	const { id, service_id, time_entry_id } = args;
+	const execCtx = ctx.executor();
+	if (action === "get") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("get"));
+		const formatted = formatTimer$1((await getTimer({
+			id,
+			include
+		}, execCtx)).data, formatOptions);
+		if (ctx.includeHints !== false) return jsonResult({
+			...formatted,
+			_hints: getTimerHints(id)
+		});
+		return jsonResult(formatted);
+	}
+	if (action === "start" || action === "create") {
+		if (!service_id && !time_entry_id) return inputErrorResult(ErrorMessages.missingServiceForTimer());
+		return jsonResult({
+			success: true,
+			...formatTimer$1((await startTimer({
+				serviceId: service_id,
+				timeEntryId: time_entry_id
+			}, execCtx)).data, formatOptions)
+		});
+	}
+	if (action === "stop") {
+		if (!id) return inputErrorResult(ErrorMessages.missingId("stop"));
+		return jsonResult({
+			success: true,
+			...formatTimer$1((await stopTimer({ id }, execCtx)).data, formatOptions)
+		});
+	}
+	if (action === "list") {
+		const result = await listTimers({
+			page,
+			perPage,
+			additionalFilters: filter,
+			include
+		}, execCtx);
+		return jsonResult(formatListResponse$1(result.data, formatTimer$1, result.meta, formatOptions));
+	}
+	return inputErrorResult(ErrorMessages.invalidAction(action, "timers", VALID_ACTIONS));
+}
+/**
+* Tool execution handlers for Productive MCP server
+* These are shared between stdio and HTTP transports
+*
+* Single consolidated tool for minimal token overhead:
+* - productive: resource + action based API
+*/
+/** Valid resources for the productive tool */
+var VALID_RESOURCES = [
+	"projects",
+	"time",
+	"tasks",
+	"services",
+	"people",
+	"companies",
+	"comments",
+	"attachments",
+	"timers",
+	"deals",
+	"bookings",
+	"budgets",
+	"pages",
+	"discussions",
+	"reports"
+];
+/** Default page size for MCP (smaller than CLI to reduce token usage) */
+var DEFAULT_PER_PAGE = 20;
+/**
+* Execute a tool with the given credentials and arguments
+*/
+async function executeToolWithCredentials(name, args, credentials) {
+	const api = new ProductiveApi({ config: {
+		apiToken: credentials.apiToken,
+		organizationId: credentials.organizationId,
+		userId: credentials.userId
+	} });
+	if (name !== "productive") return errorResult(`Unknown tool: ${name}`);
+	const { resource, action, filter, page, per_page, compact, include, query, no_hints, type, ...restArgs } = args;
+	const isCompact = compact ?? action !== "get";
+	const formatOptions = { compact: isCompact };
+	let stringFilter = toStringFilter(filter);
+	const perPage = per_page ?? DEFAULT_PER_PAGE;
+	if (query) stringFilter = {
+		...stringFilter,
+		query
+	};
+	const includeHints = no_hints !== true && action === "get" && !isCompact;
+	const execCtx = fromHandlerContext({ api });
+	const ctx = {
+		formatOptions,
+		filter: stringFilter,
+		page,
+		perPage,
+		include,
+		includeHints,
+		executor: () => execCtx
+	};
+	try {
+		if (action === "help") return resource ? handleHelp(resource) : handleHelpOverview();
+		const resolveArgs = {
+			query,
+			type
+		};
+		switch (resource) {
+			case "projects": return await handleProjects(action, {
+				...restArgs,
+				...resolveArgs
+			}, ctx);
+			case "time": return await handleTime(action, {
+				...restArgs,
+				...resolveArgs
+			}, ctx);
+			case "tasks": return await handleTasks(action, {
+				...restArgs,
+				...resolveArgs
+			}, ctx);
+			case "services": return await handleServices(action, restArgs, ctx);
+			case "people": return await handlePeople(action, {
+				...restArgs,
+				...resolveArgs
+			}, ctx, credentials);
+			case "companies": return await handleCompanies(action, {
+				...restArgs,
+				...resolveArgs
+			}, ctx);
+			case "comments": return await handleComments(action, restArgs, ctx);
+			case "attachments": return await handleAttachments(action, restArgs, ctx);
+			case "timers": return await handleTimers(action, restArgs, ctx);
+			case "deals": return await handleDeals(action, {
+				...restArgs,
+				...resolveArgs
+			}, ctx);
+			case "bookings": return await handleBookings(action, restArgs, ctx);
+			case "budgets": return await handleBudgets(action, restArgs, ctx);
+			case "pages": return await handlePages(action, restArgs, ctx);
+			case "discussions": return await handleDiscussions(action, restArgs, ctx);
+			case "reports": return await handleReports(action, restArgs, ctx);
+			default: return inputErrorResult(ErrorMessages.unknownResource(resource, VALID_RESOURCES));
+		}
+	} catch (error) {
+		if (isUserInputError(error)) return formatError(error);
+		const message = error instanceof Error ? error.message : String(error);
+		const statusMatch = message.match(/(\d{3})/);
+		if (statusMatch) {
+			const statusCode = Number.parseInt(statusMatch[1], 10);
+			return inputErrorResult(ErrorMessages.apiError(statusCode, message));
+		}
+		return errorResult(message);
+	}
+}
+export { executeToolWithCredentials as t };
+
+//# sourceMappingURL=handlers-BYE2INiR.js.map