@chronary/toolkit 0.1.2 → 1.0.1

package/dist/index.cjs

@@ -41,44 +41,92 @@ var TOOL_NAMES = [
   "get_event",
   "create_event",
   "update_event",
-  "delete_event",
-  "check_availability",
+  "cancel_event",
+  "confirm_event",
+  "release_event",
+  "create_agent",
+  "list_agents",
+  "get_agent",
+  "update_agent",
+  "delete_agent",
+  "get_availability",
+  "find_meeting_time",
+  "get_calendar_context",
+  "create_proposal",
+  "list_proposals",
+  "get_proposal",
+  "respond_to_proposal",
+  "resolve_proposal",
+  "cancel_proposal",
+  "set_availability_rules",
+  "get_availability_rules",
+  "clear_availability_rules",
   "list_webhooks",
   "get_webhook",
   "create_webhook",
   "update_webhook",
   "delete_webhook",
+  "list_webhook_deliveries",
   "list_ical_subscriptions",
   "get_ical_subscription",
-  "create_ical_subscription",
+  "subscribe_ical",
   "update_ical_subscription",
   "delete_ical_subscription",
   "sync_ical_subscription",
+  "create_scoped_key",
+  "list_scoped_keys",
+  "revoke_scoped_key",
+  "get_audit_log",
+  "accept_terms",
   "get_usage"
 ];
 
 // src/schemas.ts
 var schemas_exports = {};
 __export(schemas_exports, {
-  CheckAvailabilitySchema: () => CheckAvailabilitySchema,
+  AcceptTermsSchema: () => AcceptTermsSchema,
+  CancelEventSchema: () => CancelEventSchema,
+  CancelProposalSchema: () => CancelProposalSchema,
+  ClearAvailabilityRulesSchema: () => ClearAvailabilityRulesSchema,
+  ConfirmEventSchema: () => ConfirmEventSchema,
+  CreateAgentSchema: () => CreateAgentSchema,
   CreateCalendarSchema: () => CreateCalendarSchema,
   CreateEventSchema: () => CreateEventSchema,
-  CreateICalSubscriptionSchema: () => CreateICalSubscriptionSchema,
+  CreateProposalSchema: () => CreateProposalSchema,
+  CreateScopedKeySchema: () => CreateScopedKeySchema,
   CreateWebhookSchema: () => CreateWebhookSchema,
+  DeleteAgentSchema: () => DeleteAgentSchema,
   DeleteCalendarSchema: () => DeleteCalendarSchema,
-  DeleteEventSchema: () => DeleteEventSchema,
   DeleteICalSubscriptionSchema: () => DeleteICalSubscriptionSchema,
   DeleteWebhookSchema: () => DeleteWebhookSchema,
+  FindMeetingTimeSchema: () => FindMeetingTimeSchema,
+  GetAgentSchema: () => GetAgentSchema,
+  GetAuditLogSchema: () => GetAuditLogSchema,
+  GetAvailabilityRulesSchema: () => GetAvailabilityRulesSchema,
+  GetAvailabilitySchema: () => GetAvailabilitySchema,
+  GetCalendarContextSchema: () => GetCalendarContextSchema,
   GetCalendarSchema: () => GetCalendarSchema,
   GetEventSchema: () => GetEventSchema,
   GetICalSubscriptionSchema: () => GetICalSubscriptionSchema,
+  GetProposalSchema: () => GetProposalSchema,
   GetUsageSchema: () => GetUsageSchema,
   GetWebhookSchema: () => GetWebhookSchema,
+  ListAgentsSchema: () => ListAgentsSchema,
   ListCalendarsSchema: () => ListCalendarsSchema,
   ListEventsSchema: () => ListEventsSchema,
   ListICalSubscriptionsSchema: () => ListICalSubscriptionsSchema,
+  ListProposalsSchema: () => ListProposalsSchema,
+  ListScopedKeysSchema: () => ListScopedKeysSchema,
+  ListWebhookDeliveriesSchema: () => ListWebhookDeliveriesSchema,
   ListWebhooksSchema: () => ListWebhooksSchema,
+  ReleaseEventSchema: () => ReleaseEventSchema,
+  ResolveProposalSchema: () => ResolveProposalSchema,
+  RespondToProposalSchema: () => RespondToProposalSchema,
+  RevokeScopedKeySchema: () => RevokeScopedKeySchema,
+  SetAvailabilityRulesSchema: () => SetAvailabilityRulesSchema,
+  SubscribeICalSchema: () => SubscribeICalSchema,
   SyncICalSubscriptionSchema: () => SyncICalSubscriptionSchema,
+  UpdateAgentSchema: () => UpdateAgentSchema,
   UpdateCalendarSchema: () => UpdateCalendarSchema,
   UpdateEventSchema: () => UpdateEventSchema,
   UpdateICalSubscriptionSchema: () => UpdateICalSubscriptionSchema,
@@ -98,13 +146,15 @@ var CreateCalendarSchema = import_zod.z.object({
   name: import_zod.z.string().describe("Calendar name"),
   timezone: import_zod.z.string().describe('IANA timezone (e.g., "America/New_York")'),
   agent_id: import_zod.z.string().optional().describe("Agent ID to associate the calendar with"),
-  metadata: import_zod.z.record(import_zod.z.unknown()).optional().describe("Arbitrary key-value metadata")
+  default_reminders: import_zod.z.array(import_zod.z.number().int().min(1).max(40320)).max(5).nullable().optional().describe("Default reminder offsets in minutes before start, inherited by events that don't set their own (e.g. [10, 1440]). null/omit = system default (10 min); [] = no reminders. Max 5, each 1\u201340320."),
+  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional().describe("Arbitrary key-value metadata")
 });
 var UpdateCalendarSchema = import_zod.z.object({
   calendar_id: import_zod.z.string().describe("The calendar ID to update"),
   name: import_zod.z.string().optional().describe("New calendar name"),
   timezone: import_zod.z.string().optional().describe("New IANA timezone"),
-  metadata: import_zod.z.record(import_zod.z.unknown()).optional().describe("Updated metadata")
+  default_reminders: import_zod.z.array(import_zod.z.number().int().min(1).max(40320)).max(5).nullable().optional().describe("New default reminder offsets in minutes before start. null = system default (10 min); [] = no reminders. Max 5, each 1\u201340320."),
+  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional().describe("Updated metadata")
 });
 var DeleteCalendarSchema = import_zod.z.object({
   calendar_id: import_zod.z.string().describe("The calendar ID to delete")
@@ -131,7 +181,8 @@ var CreateEventSchema = import_zod.z.object({
   description: import_zod.z.string().optional().describe("Event description"),
   all_day: import_zod.z.boolean().optional().describe("Whether this is an all-day event"),
   status: import_zod.z.enum(["confirmed", "tentative", "cancelled"]).optional().describe('Event status (default "confirmed")'),
-  metadata: import_zod.z.record(import_zod.z.unknown()).optional().describe("Arbitrary key-value metadata")
+  reminders: import_zod.z.array(import_zod.z.number().int().min(1).max(40320)).max(5).nullable().optional().describe("Reminder offsets in minutes before start (e.g. [10, 1440]). Each fires an event.reminder webhook. null/omit = inherit calendar default (then 10 min); [] = no reminders. Max 5, each 1\u201340320."),
+  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional().describe("Arbitrary key-value metadata")
 });
 var UpdateEventSchema = import_zod.z.object({
   calendar_id: import_zod.z.string().describe("Calendar ID the event belongs to"),
@@ -142,20 +193,145 @@ var UpdateEventSchema = import_zod.z.object({
   end_time: import_zod.z.string().optional().describe("New end time in ISO 8601 format"),
   all_day: import_zod.z.boolean().optional().describe("Whether this is an all-day event"),
   status: import_zod.z.enum(["confirmed", "tentative", "cancelled"]).optional().describe("New event status"),
-  metadata: import_zod.z.record(import_zod.z.unknown()).optional().describe("Updated metadata")
+  reminders: import_zod.z.array(import_zod.z.number().int().min(1).max(40320)).max(5).nullable().optional().describe("New reminder offsets in minutes before start. null = inherit calendar default; [] = no reminders. Max 5, each 1\u201340320."),
+  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional().describe("Updated metadata")
 });
-var DeleteEventSchema = import_zod.z.object({
-  calendar_id: import_zod.z.string().describe("Calendar ID the event belongs to"),
-  event_id: import_zod.z.string().describe("The event ID to delete")
-});
-var CheckAvailabilitySchema = import_zod.z.object({
-  agents: import_zod.z.array(import_zod.z.string()).min(1).describe("Agent IDs to check availability for"),
-  start: import_zod.z.string().describe("Start of time range in ISO 8601 format"),
-  end: import_zod.z.string().describe("End of time range in ISO 8601 format"),
-  slot_duration: import_zod.z.enum(["15m", "30m", "45m", "1h", "2h"]).optional().describe('Duration of availability slots (default "30m")'),
-  calendars: import_zod.z.array(import_zod.z.string()).optional().describe("Specific calendar IDs to check (default: all agent calendars)"),
+var CancelEventSchema = import_zod.z.object({
+  calendar_id: import_zod.z.string().describe("Calendar ID that owns the event"),
+  event_id: import_zod.z.string().describe("Event ID to cancel")
+});
+var ConfirmEventSchema = import_zod.z.object({
+  event_id: import_zod.z.string().describe("Event ID of the hold to confirm")
+});
+var ReleaseEventSchema = import_zod.z.object({
+  event_id: import_zod.z.string().describe("Event ID of the hold to release")
+});
+var CreateAgentSchema = import_zod.z.object({
+  name: import_zod.z.string().min(1).max(255).describe("Display name for the agent"),
+  type: import_zod.z.enum(["ai", "human", "resource"]).describe("Agent type"),
+  description: import_zod.z.string().optional().describe("Optional description"),
+  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional().describe("Arbitrary key-value metadata")
+});
+var ListAgentsSchema = import_zod.z.object({
+  type: import_zod.z.enum(["ai", "human", "resource"]).optional().describe("Filter by agent type"),
+  status: import_zod.z.enum(["active", "paused", "decommissioned"]).optional().describe("Filter by status"),
+  limit: import_zod.z.number().int().min(1).max(200).optional().describe("Max results per page (default 50)"),
+  offset: import_zod.z.number().int().min(0).optional().describe("Pagination offset (default 0)")
+});
+var GetAgentSchema = import_zod.z.object({
+  agent_id: import_zod.z.string().describe("Agent ID to fetch")
+});
+var UpdateAgentSchema = import_zod.z.object({
+  agent_id: import_zod.z.string().describe("Agent ID to update"),
+  name: import_zod.z.string().min(1).max(255).optional().describe("New display name"),
+  description: import_zod.z.string().nullable().optional().describe("New description (null to clear)"),
+  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional().describe("Arbitrary metadata (max 16KB)"),
+  status: import_zod.z.enum(["active", "paused"]).optional().describe("Operational status")
+});
+var DeleteAgentSchema = import_zod.z.object({
+  agent_id: import_zod.z.string().describe("Agent ID to decommission")
+});
+var GetAvailabilitySchema = import_zod.z.object({
+  agent_id: import_zod.z.string().describe("Agent ID to check availability for"),
+  start: import_zod.z.string().describe("Range start (ISO 8601)"),
+  end: import_zod.z.string().describe("Range end (ISO 8601)"),
+  slot_duration: import_zod.z.enum(["15m", "30m", "45m", "1h", "2h"]).optional().describe('Minimum slot duration required (default "30m")'),
   include_busy: import_zod.z.boolean().optional().describe("Include busy blocks in response")
 });
+var FindMeetingTimeSchema = import_zod.z.object({
+  agents: import_zod.z.array(import_zod.z.string()).min(1).describe("Array of agent IDs to find common free time for. All agents must be free during the returned slots."),
+  start: import_zod.z.string().describe("Search range start (ISO 8601)"),
+  end: import_zod.z.string().describe("Search range end (ISO 8601)"),
+  slot_duration: import_zod.z.enum(["15m", "30m", "45m", "1h", "2h"]).optional().describe('Minimum slot duration required (default "30m")'),
+  calendars: import_zod.z.array(import_zod.z.string()).optional().describe("Additional shared calendar IDs to treat as busy"),
+  include_busy: import_zod.z.boolean().optional().describe("Include per-agent busy blocks in response")
+});
+var GetCalendarContextSchema = import_zod.z.object({
+  calendar_id: import_zod.z.string().describe("Calendar ID")
+});
+var proposalSlotSchema = import_zod.z.object({
+  start_time: import_zod.z.string().describe("Slot start (ISO 8601)"),
+  end_time: import_zod.z.string().describe("Slot end (ISO 8601)"),
+  weight: import_zod.z.number().min(0).max(10).optional().describe("Preference weight (default 1.0)"),
+  calendar_id: import_zod.z.string().optional().describe("Override calendar for this slot")
+});
+var CreateProposalSchema = import_zod.z.object({
+  title: import_zod.z.string().min(1).max(500).describe("Short description of what the meeting is about"),
+  description: import_zod.z.string().max(5e3).optional().describe("Longer context/agenda"),
+  organizer_agent_id: import_zod.z.string().describe("Agent ID proposing the meeting"),
+  participant_agent_ids: import_zod.z.array(import_zod.z.string()).min(1).max(50).describe("Agent IDs invited to respond"),
+  calendar_id: import_zod.z.string().describe("Calendar the resolved event will be created on"),
+  slots: import_zod.z.array(proposalSlotSchema).min(1).max(20).describe("Candidate time slots (up to 20)"),
+  expires_at: import_zod.z.string().optional().describe("Auto-cancel cutoff if unresolved (ISO 8601)")
+});
+var ListProposalsSchema = import_zod.z.object({
+  status: import_zod.z.enum(["pending", "confirmed", "expired", "cancelled"]).optional().describe("Filter by proposal status"),
+  organizer_agent_id: import_zod.z.string().optional().describe("Filter by organizer agent"),
+  limit: import_zod.z.number().int().min(1).max(200).optional().describe("Max results (default 50)"),
+  offset: import_zod.z.number().int().min(0).optional().describe("Pagination offset (default 0)")
+});
+var GetProposalSchema = import_zod.z.object({
+  proposal_id: import_zod.z.string().describe("Proposal to fetch")
+});
+var RespondToProposalSchema = import_zod.z.object({
+  proposal_id: import_zod.z.string().describe("Proposal to respond to"),
+  agent_id: import_zod.z.string().describe("Participant agent responding"),
+  response: import_zod.z.enum(["accept", "decline", "counter"]).describe("Decision from this agent"),
+  selected_slot_id: import_zod.z.string().optional().describe('Required when response is "accept"'),
+  counter_slots: import_zod.z.array(proposalSlotSchema).max(20).optional().describe('Alternative slots when response is "counter"'),
+  message: import_zod.z.string().max(2e3).optional().describe("Optional note for the organizer")
+});
+var ResolveProposalSchema = import_zod.z.object({
+  proposal_id: import_zod.z.string().describe("Proposal to resolve")
+});
+var CancelProposalSchema = import_zod.z.object({
+  proposal_id: import_zod.z.string().describe("Proposal to cancel")
+});
+var workingHoursDaySchema = import_zod.z.object({
+  start: import_zod.z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "must be HH:MM in 24-hour time"),
+  end: import_zod.z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "must be HH:MM in 24-hour time")
+});
+var workingHoursSchema = import_zod.z.object({
+  mon: workingHoursDaySchema.optional(),
+  tue: workingHoursDaySchema.optional(),
+  wed: workingHoursDaySchema.optional(),
+  thu: workingHoursDaySchema.optional(),
+  fri: workingHoursDaySchema.optional(),
+  sat: workingHoursDaySchema.optional(),
+  sun: workingHoursDaySchema.optional()
+}).nullable();
+var SetAvailabilityRulesSchema = import_zod.z.object({
+  calendar_id: import_zod.z.string().describe("Calendar to configure"),
+  buffer_before_minutes: import_zod.z.number().int().min(0).max(120).optional().describe("Minutes of buffer before each event (0\u2013120)"),
+  buffer_after_minutes: import_zod.z.number().int().min(0).max(120).optional().describe("Minutes of buffer after each event (0\u2013120)"),
+  working_hours: workingHoursSchema.optional().describe("Per-day working hours map in the calendar's timezone; omit keys for off-days. Pass null to remove any working-hours constraint."),
+  timezone: import_zod.z.string().min(1).max(64).optional().describe("IANA timezone used to interpret working_hours (e.g. America/New_York)")
+});
+var GetAvailabilityRulesSchema = import_zod.z.object({
+  calendar_id: import_zod.z.string().describe("Calendar to read")
+});
+var ClearAvailabilityRulesSchema = import_zod.z.object({
+  calendar_id: import_zod.z.string().describe("Calendar whose rules should be cleared")
+});
+var CreateScopedKeySchema = import_zod.z.object({
+  agent_id: import_zod.z.string().regex(/^agt_/).describe("Agent ID this key is scoped to"),
+  label: import_zod.z.string().min(1).max(100).optional().describe("Human-readable label for the key")
+});
+var ListScopedKeysSchema = import_zod.z.object({});
+var RevokeScopedKeySchema = import_zod.z.object({
+  key_id: import_zod.z.string().describe("ID of the scoped key to revoke")
+});
+var GetAuditLogSchema = import_zod.z.object({
+  from: import_zod.z.string().optional().describe("Start of the window (ISO 8601). Silently clamped to the plan retention window if older."),
+  to: import_zod.z.string().optional().describe("End of the window (ISO 8601)"),
+  action: import_zod.z.string().min(1).max(64).optional().describe("Filter by action name (e.g. event.created)"),
+  actor_key_prefix: import_zod.z.string().min(1).max(32).optional().describe("Filter by the API key prefix that performed the action"),
+  cursor: import_zod.z.string().min(1).max(256).optional().describe("Opaque pagination cursor from a previous response"),
+  limit: import_zod.z.number().int().min(1).max(200).optional().describe("Max results to return (default 50)")
+});
+var AcceptTermsSchema = import_zod.z.object({
+  tos_version: import_zod.z.string().min(1).describe("The terms-of-service version to accept; must match the current version")
+});
 var ListWebhooksSchema = import_zod.z.object({
   limit: import_zod.z.number().int().min(1).max(100).optional().describe("Max results per page (default 20)"),
   offset: import_zod.z.number().int().min(0).optional().describe("Pagination offset (default 0)")
@@ -185,11 +361,18 @@ var ListICalSubscriptionsSchema = import_zod.z.object({
 var GetICalSubscriptionSchema = import_zod.z.object({
   subscription_id: import_zod.z.string().describe("The iCal subscription ID to retrieve")
 });
-var CreateICalSubscriptionSchema = import_zod.z.object({
-  agent_id: import_zod.z.string().describe("Agent ID to create the subscription for"),
-  calendar_id: import_zod.z.string().describe("Calendar ID to import events into"),
-  url: import_zod.z.string().describe("HTTPS URL of the iCal feed to subscribe to"),
-  label: import_zod.z.string().optional().describe("Human-readable label for the subscription")
+var SubscribeICalSchema = import_zod.z.object({
+  agent_id: import_zod.z.string().describe("Agent ID that will own this subscription"),
+  calendar_id: import_zod.z.string().describe("Calendar ID to sync external events into"),
+  url: import_zod.z.string().url().describe("HTTPS URL of the iCal feed (.ics) to subscribe to"),
+  label: import_zod.z.string().optional().describe("Optional label for this subscription")
+});
+var ListWebhookDeliveriesSchema = import_zod.z.object({
+  webhook_id: import_zod.z.string().describe("Webhook subscription whose deliveries to list"),
+  limit: import_zod.z.number().int().min(1).max(100).optional().describe("Max results to return (default 20)"),
+  offset: import_zod.z.number().int().min(0).optional().describe("Pagination offset (default 0)"),
+  status: import_zod.z.enum(["pending", "delivered", "failed"]).optional().describe("Filter to a single delivery status"),
+  include_payload: import_zod.z.boolean().optional().describe("Include the full event payload sent on each delivery")
 });
 var UpdateICalSubscriptionSchema = import_zod.z.object({
   subscription_id: import_zod.z.string().describe("The iCal subscription ID to update"),
@@ -242,6 +425,7 @@ var createCalendar = safeFunc(async (ctx) => {
     name: params.name,
     timezone: params.timezone,
     agentId: params.agent_id,
+    default_reminders: params.default_reminders,
     metadata: params.metadata
   });
 });
@@ -280,13 +464,99 @@ var updateEvent = safeFunc(async (ctx) => {
   const { calendar_id, event_id, ...updates } = params;
   return client.events.update(calendar_id, event_id, updates);
 });
-var deleteEvent = safeFunc(async (ctx) => {
+var cancelEvent = safeFunc(async (ctx) => {
   await ctx.client.events.delete(ctx.params.calendar_id, ctx.params.event_id);
   return void 0;
 });
-var checkAvailability = safeFunc(async (ctx) => {
+var confirmEvent = safeFunc(async (ctx) => {
+  return ctx.client.events.confirm(ctx.params.event_id);
+});
+var releaseEvent = safeFunc(async (ctx) => {
+  return ctx.client.events.release(ctx.params.event_id);
+});
+var createAgent = safeFunc(async (ctx) => {
+  return ctx.client.agents.create(ctx.params);
+});
+var listAgents = safeFunc(async (ctx) => {
+  const { client, params } = ctx;
+  const iter = client.agents.list({ type: params.type, status: params.status, limit: params.limit });
+  return fetchPage(iter, params.offset, params.limit);
+});
+var getAgent = safeFunc(async (ctx) => {
+  return ctx.client.agents.get(ctx.params.agent_id);
+});
+var updateAgent = safeFunc(async (ctx) => {
+  const { client, params } = ctx;
+  const { agent_id, ...updates } = params;
+  return client.agents.update(agent_id, updates);
+});
+var deleteAgent = safeFunc(async (ctx) => {
+  await ctx.client.agents.delete(ctx.params.agent_id);
+  return void 0;
+});
+var getAvailability = safeFunc(async (ctx) => {
+  const { client, params } = ctx;
+  return client.availability.forAgent(params.agent_id, {
+    start: params.start,
+    end: params.end,
+    slot_duration: params.slot_duration,
+    include_busy: params.include_busy
+  });
+});
+var findMeetingTime = safeFunc(async (ctx) => {
   return ctx.client.availability.check(ctx.params);
 });
+var getCalendarContext = safeFunc(async (ctx) => {
+  return ctx.client.calendars.getContext(ctx.params.calendar_id);
+});
+var createProposal = safeFunc(async (ctx) => {
+  return ctx.client.scheduling.create(ctx.params);
+});
+var listProposals = safeFunc(async (ctx) => {
+  const { client, params } = ctx;
+  const iter = client.scheduling.list({
+    status: params.status,
+    organizer_agent_id: params.organizer_agent_id,
+    limit: params.limit
+  });
+  return fetchPage(iter, params.offset, params.limit);
+});
+var getProposal = safeFunc(async (ctx) => {
+  return ctx.client.scheduling.get(ctx.params.proposal_id);
+});
+var respondToProposal = safeFunc(async (ctx) => {
+  const { client, params } = ctx;
+  const { proposal_id, ...body } = params;
+  return client.scheduling.respond(proposal_id, body);
+});
+var resolveProposal = safeFunc(async (ctx) => {
+  return ctx.client.scheduling.resolve(ctx.params.proposal_id);
+});
+var cancelProposal = safeFunc(async (ctx) => {
+  return ctx.client.scheduling.cancel(ctx.params.proposal_id);
+});
+var setAvailabilityRules = safeFunc(async (ctx) => {
+  const { client, params } = ctx;
+  const { calendar_id, ...rules } = params;
+  return client.calendars.setAvailabilityRules(calendar_id, rules);
+});
+var getAvailabilityRules = safeFunc(async (ctx) => {
+  return ctx.client.calendars.getAvailabilityRules(ctx.params.calendar_id);
+});
+var clearAvailabilityRules = safeFunc(async (ctx) => {
+  await ctx.client.calendars.deleteAvailabilityRules(ctx.params.calendar_id);
+  return void 0;
+});
+var createScopedKey = safeFunc(async (ctx) => {
+  return ctx.client.keys.create(ctx.params);
+});
+var listScopedKeys = safeFunc(async (ctx) => {
+  return ctx.client.keys.list();
+});
+var revokeScopedKey = safeFunc(async (ctx) => {
+  await ctx.client.keys.delete(ctx.params.key_id);
+  return void 0;
+});
 var listWebhooks = safeFunc(async (ctx) => {
   const { client, params } = ctx;
   const iter = client.webhooks.list({ limit: params.limit });
@@ -307,6 +577,17 @@ var deleteWebhook = safeFunc(async (ctx) => {
   await ctx.client.webhooks.delete(ctx.params.webhook_id);
   return void 0;
 });
+var listWebhookDeliveries = safeFunc(async (ctx) => {
+  const { client, params } = ctx;
+  const { webhook_id, ...query } = params;
+  return client.webhooks.listDeliveries(webhook_id, query);
+});
+var getAuditLog = safeFunc(async (ctx) => {
+  return ctx.client.auditLog.list(ctx.params);
+});
+var acceptTerms = safeFunc(async (ctx) => {
+  return ctx.client.terms.accept(ctx.params);
+});
 var listICalSubscriptions = safeFunc(async (ctx) => {
   const { client, params } = ctx;
   const iter = client.icalSubscriptions.list({
@@ -319,7 +600,7 @@ var listICalSubscriptions = safeFunc(async (ctx) => {
 var getICalSubscription = safeFunc(async (ctx) => {
   return ctx.client.icalSubscriptions.get(ctx.params.subscription_id);
 });
-var createICalSubscription = safeFunc(async (ctx) => {
+var subscribeICal = safeFunc(async (ctx) => {
   const { client, params } = ctx;
   const { agent_id, ...subParams } = params;
   return client.icalSubscriptions.create(agent_id, subParams);
@@ -350,12 +631,19 @@ var HOSTED_API_MCP_TOOL_NAMES = [
   "create_calendar",
   "create_event",
   "list_events",
+  "get_event",
+  "update_event",
   "get_availability",
   "find_meeting_time",
   "cancel_event",
   "confirm_event",
   "release_event",
   "subscribe_ical",
+  "list_ical_subscriptions",
+  "get_ical_subscription",
+  "update_ical_subscription",
+  "delete_ical_subscription",
+  "sync_ical_subscription",
   "get_calendar_context",
   "create_proposal",
   "list_proposals",
@@ -365,7 +653,26 @@ var HOSTED_API_MCP_TOOL_NAMES = [
   "cancel_proposal",
   "set_availability_rules",
   "get_availability_rules",
-  "clear_availability_rules"
+  "clear_availability_rules",
+  "create_scoped_key",
+  "list_scoped_keys",
+  "revoke_scoped_key",
+  "create_webhook",
+  "list_webhooks",
+  "get_webhook",
+  "update_webhook",
+  "delete_webhook",
+  "list_webhook_deliveries",
+  "get_agent",
+  "update_agent",
+  "delete_agent",
+  "list_calendars",
+  "get_calendar",
+  "update_calendar",
+  "delete_calendar",
+  "get_usage",
+  "get_audit_log",
+  "accept_terms"
 ];
 var TOOL_DEFINITIONS = [
   // ── Calendars ──────────────────────────────────────────────────
@@ -434,19 +741,149 @@ var TOOL_DEFINITIONS = [
     execute: createExecutor(updateEvent)
   },
   {
-    name: "delete_event",
-    description: "Delete an event from a calendar. This frees the agent's availability during that time.",
-    schema: DeleteEventSchema,
-    annotations: { title: "Delete Event", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
-    execute: createExecutor(deleteEvent)
+    name: "cancel_event",
+    description: "Delete or cancel an event from a calendar. The event is marked cancelled and excluded from future availability calculations.",
+    schema: CancelEventSchema,
+    annotations: { title: "Cancel Event", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(cancelEvent)
+  },
+  {
+    name: "confirm_event",
+    description: 'Promote a held event to a confirmed booking. The event must currently have status="hold" and its hold_expires_at must not have passed.',
+    schema: ConfirmEventSchema,
+    annotations: { title: "Confirm Event", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(confirmEvent)
+  },
+  {
+    name: "release_event",
+    description: 'Manually release a held event before its hold_expires_at. The event must currently have status="hold". Frees the slot for other agents to book.',
+    schema: ReleaseEventSchema,
+    annotations: { title: "Release Event", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(releaseEvent)
+  },
+  // ── Agents ─────────────────────────────────────────────────────
+  {
+    name: "create_agent",
+    description: "Register your agent (AI assistant, human participant, or resource) with Chronary so it can own calendars, events, and webhooks.",
+    schema: CreateAgentSchema,
+    annotations: { title: "Create Agent", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    execute: createExecutor(createAgent)
+  },
+  {
+    name: "list_agents",
+    description: "List all agents in your organization. Returns paginated results.",
+    schema: ListAgentsSchema,
+    annotations: { title: "List Agents", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(listAgents)
+  },
+  {
+    name: "get_agent",
+    description: "Fetch a single agent by ID. An agent represents an AI assistant, human, or shared resource (e.g. a meeting room).",
+    schema: GetAgentSchema,
+    annotations: { title: "Get Agent", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(getAgent)
+  },
+  {
+    name: "update_agent",
+    description: "Update an agent's name, description, metadata, or status (active/paused). Requires an org-level API key.",
+    schema: UpdateAgentSchema,
+    annotations: { title: "Update Agent", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(updateAgent)
+  },
+  {
+    name: "delete_agent",
+    description: "Decommission an agent. This marks the agent as decommissioned and revokes all of its scoped API keys. Requires an org-level API key.",
+    schema: DeleteAgentSchema,
+    annotations: { title: "Delete Agent", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(deleteAgent)
   },
   // ── Availability ───────────────────────────────────────────────
   {
-    name: "check_availability",
-    description: "Check free/busy availability across one or more agents within a time range. Returns available time slots and optionally busy blocks.",
-    schema: CheckAvailabilitySchema,
-    annotations: { title: "Check Availability", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    execute: createExecutor(checkAvailability)
+    name: "get_availability",
+    description: "Check when a single agent is free within a time range. Returns available time slots and optionally busy blocks.",
+    schema: GetAvailabilitySchema,
+    annotations: { title: "Get Availability", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(getAvailability)
+  },
+  {
+    name: "find_meeting_time",
+    description: "Find time slots when multiple agents are all free simultaneously. All agents must be free during the returned slots.",
+    schema: FindMeetingTimeSchema,
+    annotations: { title: "Find Meeting Time", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(findMeetingTime)
+  },
+  // ── Calendar context ───────────────────────────────────────────
+  {
+    name: "get_calendar_context",
+    description: "Get a calendar's temporal context in a single call: the current event, the next upcoming event, recent past events, a short upcoming window, and the owning agent's status.",
+    schema: GetCalendarContextSchema,
+    annotations: { title: "Get Calendar Context", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(getCalendarContext)
+  },
+  // ── Scheduling proposals ───────────────────────────────────────
+  {
+    name: "create_proposal",
+    description: "Create a scheduling proposal \u2014 send candidate time slots to one or more participant agents so they can accept, decline, or counter-propose. Requires an org-level API key. Pro plan only.",
+    schema: CreateProposalSchema,
+    annotations: { title: "Create Proposal", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    execute: createExecutor(createProposal)
+  },
+  {
+    name: "list_proposals",
+    description: "List scheduling proposals for the org. Filter by status or organizer_agent_id. Requires an org-level API key.",
+    schema: ListProposalsSchema,
+    annotations: { title: "List Proposals", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(listProposals)
+  },
+  {
+    name: "get_proposal",
+    description: "Get a scheduling proposal by id, including its slots and per-participant responses. Requires an org-level API key.",
+    schema: GetProposalSchema,
+    annotations: { title: "Get Proposal", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(getProposal)
+  },
+  {
+    name: "respond_to_proposal",
+    description: "Submit a response (accept / decline / counter) on behalf of one participant agent to an open proposal. Requires an org-level API key. Pro plan only.",
+    schema: RespondToProposalSchema,
+    annotations: { title: "Respond To Proposal", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    execute: createExecutor(respondToProposal)
+  },
+  {
+    name: "resolve_proposal",
+    description: "Force-resolve an open proposal using responses collected so far. Picks the highest-scoring slot and creates a confirmed calendar event. Requires an org-level API key. Pro plan only.",
+    schema: ResolveProposalSchema,
+    annotations: { title: "Resolve Proposal", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(resolveProposal)
+  },
+  {
+    name: "cancel_proposal",
+    description: 'Cancel an open proposal. Fires a proposal.cancelled webhook with reason="organizer_cancelled". Requires an org-level API key. Pro plan only.',
+    schema: CancelProposalSchema,
+    annotations: { title: "Cancel Proposal", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(cancelProposal)
+  },
+  // ── Availability rules ─────────────────────────────────────────
+  {
+    name: "set_availability_rules",
+    description: "Set or replace the availability rules on a calendar \u2014 buffer times before/after events and optional per-day working hours. Upsert: overwrites any existing rules.",
+    schema: SetAvailabilityRulesSchema,
+    annotations: { title: "Set Availability Rules", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(setAvailabilityRules)
+  },
+  {
+    name: "get_availability_rules",
+    description: "Read the buffer times and working-hours rules configured on a calendar. Returns the rules row, or an error if none are set.",
+    schema: GetAvailabilityRulesSchema,
+    annotations: { title: "Get Availability Rules", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(getAvailabilityRules)
+  },
+  {
+    name: "clear_availability_rules",
+    description: "Remove the availability rules from a calendar, reverting to the default (no buffers, no working-hours mask).",
+    schema: ClearAvailabilityRulesSchema,
+    annotations: { title: "Clear Availability Rules", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(clearAvailabilityRules)
   },
   // ── Webhooks ───────────────────────────────────────────────────
   {
@@ -484,6 +921,13 @@ var TOOL_DEFINITIONS = [
     annotations: { title: "Delete Webhook", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
     execute: createExecutor(deleteWebhook)
   },
+  {
+    name: "list_webhook_deliveries",
+    description: "List delivery attempts for a webhook subscription, with per-status counts (pending/delivered/failed). Use this to debug failing deliveries. Requires an org-level API key.",
+    schema: ListWebhookDeliveriesSchema,
+    annotations: { title: "List Webhook Deliveries", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(listWebhookDeliveries)
+  },
   // ── iCal Subscriptions ─────────────────────────────────────────
   {
     name: "list_ical_subscriptions",
@@ -500,11 +944,11 @@ var TOOL_DEFINITIONS = [
     execute: createExecutor(getICalSubscription)
   },
   {
-    name: "create_ical_subscription",
-    description: "Import an external calendar by subscribing to an iCal feed URL. Events are synced every 30 minutes.",
-    schema: CreateICalSubscriptionSchema,
-    annotations: { title: "Create iCal Subscription", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
-    execute: createExecutor(createICalSubscription)
+    name: "subscribe_ical",
+    description: "Link an external iCal feed (e.g. a human's Google Calendar) to an agent's calendar so external events appear in availability calculations. Events are synced every 30 minutes.",
+    schema: SubscribeICalSchema,
+    annotations: { title: "Subscribe iCal", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    execute: createExecutor(subscribeICal)
   },
   {
     name: "update_ical_subscription",
@@ -527,6 +971,44 @@ var TOOL_DEFINITIONS = [
     annotations: { title: "Sync iCal Subscription", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     execute: createExecutor(syncICalSubscription)
   },
+  // ── Scoped keys ────────────────────────────────────────────────
+  {
+    name: "create_scoped_key",
+    description: "Create an agent-scoped API key (chr_ak_*) that can only act on behalf of a single agent. The plaintext key is returned exactly once. Requires an org-level API key.",
+    schema: CreateScopedKeySchema,
+    annotations: { title: "Create Scoped Key", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    execute: createExecutor(createScopedKey)
+  },
+  {
+    name: "list_scoped_keys",
+    description: "List all live (non-revoked) agent-scoped API keys for this org. Returns key metadata only \u2014 never the plaintext secret. Requires an org-level API key.",
+    schema: ListScopedKeysSchema,
+    annotations: { title: "List Scoped Keys", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(listScopedKeys)
+  },
+  {
+    name: "revoke_scoped_key",
+    description: "Revoke an agent-scoped API key by ID. The key stops authenticating immediately and cannot be un-revoked. Requires an org-level API key.",
+    schema: RevokeScopedKeySchema,
+    annotations: { title: "Revoke Scoped Key", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(revokeScopedKey)
+  },
+  // ── Audit log ──────────────────────────────────────────────────
+  {
+    name: "get_audit_log",
+    description: "List audit-log entries for the calling org \u2014 mutating operations and auth-lifecycle events, newest first. Results are clamped to the plan's retention window. Requires an org-level API key.",
+    schema: GetAuditLogSchema,
+    annotations: { title: "Get Audit Log", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(getAuditLog)
+  },
+  // ── Terms ──────────────────────────────────────────────────────
+  {
+    name: "accept_terms",
+    description: "Re-accept the current Chronary terms of service on behalf of the calling org. Use this when responses carry the Chronary-Terms-Upgrade-Required header. Requires an org-level API key.",
+    schema: AcceptTermsSchema,
+    annotations: { title: "Accept Terms", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    execute: createExecutor(acceptTerms)
+  },
   // ── Usage ──────────────────────────────────────────────────────
   {
     name: "get_usage",