node-autotask 0.11.0 → 0.12.1

package/docs/API.md

@@ -847,7 +847,7 @@ be cross-mode-refused.
 whose MCP annotation is `readOnlyHint !== true` — today exactly **254
 tools**: the 252 dedicated write/delete tools (198 `effect=write` + 54
 `effect=destructive`, every one of them has a dedicated tool) +
-`autotask_write` + `autotask_delete`. The remaining **600 tools** (the 587
+`autotask_write` + `autotask_delete`. The remaining **601 tools** (the 588
 dedicated read tools + the 10 core read tools + `autotask_read` +
 `autotask_catalog` + `autotask_describe`) all carry `readOnlyHint: true`
 and are safe ungated: every op they can route is `effect=read` (zero
@@ -1145,7 +1145,7 @@ Standard methods (every resource, `BaseResource`): `query` (stream, 1000-page gu
 | `contract_service_units` | ContractServiceUnit | entity | extended | yes (contracts) | query, count, get, resolve | getEntityInfo, getFieldInfo, getUdfInfo | autotask_contractServiceUnit_get |
 | `contract_services` | ContractService | entity | extended | yes (contracts) | query, count, get, create, update, resolve | createIfNotExists, getEntityInfo, getFieldInfo, getUdfInfo | autotask_contractService_get |
 | `contract_ticket_purchases` | ContractTicketPurchases | entity | extended | yes (contracts) | query, count, get, create, update, resolve | getEntityInfo, getFieldInfo, getUdfInfo | autotask_contractTicketPurchase_get |
-| `contracts` | Contract | entity | extended | no | query, count, get, create, update, resolve, search | createIfNotExists, getEntityInfo, getFieldInfo, getUdfInfo | autotask_contract_get |
+| `contracts` | Contract | entity | extended | no | query, count, get, create, update, resolve, search | createIfNotExists, getEntityInfo, getFieldInfo, getUdfInfo, profitability | autotask_contract_get |
 | `countries` | Country | entity | advanced | no | query, count, get, update, resolve, search | getEntityInfo, getFieldInfo, getUdfInfo | autotask_country_get |
 | `departments` | Department | entity | extended | no | query, count, get, create, update, resolve, search | getEntityInfo, getFieldInfo, getUdfInfo | autotask_department_get |
 | `domain_registrars` | DomainRegistrar | entity | extended | no | query, count, get, create, update, resolve, search | getEntityInfo, getFieldInfo, getUdfInfo | autotask_DomainRegistrar_get |
@@ -2601,6 +2601,305 @@ resource's query surface is pinned blind), and `next` (concrete next steps; the
 remedy names the authority op). Hit paths carry no `miss` key. Thrown outcomes
 (`NOT_FOUND` by numeric id, `RESOLUTION_AMBIGUOUS`, `RESOLUTION_TRUNCATED`) are unchanged.
 
+### 11.26 The contract P&L composite — `contracts.profitability` (issue #100)
+
+Issue #100 adds the contract profit-and-loss composite op (an additive read;
+the plan change — a new registry op — is a minor at publish). One call
+returns the contract's reconciled P&L over a date window:
+
+- **`contracts.profitability(contractId, opts)` — the closed opts bag.**
+  `dateFrom`/`dateTo` are required (`YYYY-MM-DD`, `dateTo >= dateFrom`) and
+  the window is capped at 36 calendar months (the per-month windowing budget
+  stays bounded; OQ1). `labourCostMethod` (default
+  `billing_item_our_cost`; the closed 4-set
+  `billing_item_our_cost` / `contract_role_cost` / `resource_internal_cost` /
+  `provided`) selects the START rung of the cost-rate ladder;
+  `labourRatePerHour` (finite `>= 0`) is the `provided` catch-all rung and is
+  REQUIRED when `labourCostMethod` is `provided`. `includeRecurringCosts` /
+  `includeUnbilledRevenue` (default true) gate the charges/units folds and
+  the expected-revenue basis; `externalMonthlyCosts` (finite `>= 0`, indexed
+  by month from `dateFrom`, at most one entry per window month) is the
+  caller-supplied non-vendor tooling cost, surfaced in
+  `tooling_cost.caller_supplied` (stamped non-vendor — never folded into the
+  vendor figure); `groupByActivity` (default true) gates the
+  `ticketCategory` activity fold; `staleAfterDays` (default 30, integer `>=
+  1`) is the open-stale horizon; `maxTicketsForJoin` (default 500, integer
+  1..500) caps the ticket join set fed to the expenses + miscoding probe
+  (sorted, first N, the `N of M` note) and the time-referenced ticket ids;
+  `limit` (default 50, clamped 500) is
+  every part's `MaxRecords` + the capped lists. Validation collects the
+  COMPLETE problem list and throws ONE typed `CONFIG_ERROR` pre-request —
+  zero wire on any malformed bag (the refusal table is house style: every
+  message names the key + the valid values).
+- **Wire plan: ≤21 bounded reads, zero mutating, all pre-existing ops.**
+  Issue order: contract `get` → customer `GET /V1.0/Companies/{companyID}` →
+  the Contracts `entityInformation/fields` read (the `contractType` LABEL —
+  verified on the ww29 sandbox 2026-10-16: 1 Time & Materials, 3 Fixed
+  Price, 4 Block Hours, 6 Retainer, 7 Recurring Service, 8 Per Ticket, 9
+  Umbrella; the folds still branch on `/block\s*hours?/i` and
+  `/time.*materials?/i` over the label, never an id; `contractCategory` is
+  ignored — all its values are inactive; an absent/0 type skips the read; an absent type, an
+  unlisted id or a catalog fault is `CONTRACT_TYPE_UNKNOWN`, surfaced in
+  `contract_type { id, label, absent? }`) → `ContractServices` / `ContractServiceUnits` (windowed on the period
+  `startDate`) / `ContractCharges` / `ContractRoleCosts` / `ContractRates`
+  queries → `ContractBlocks` query (Block Hours contracts only, by label;
+  skipped otherwise) → `BillingItems` query → invoices
+  (fetch-by-ids on the distinct billed `invoiceID`s; skipped on none) →
+  `TimeEntries` query → `Tickets` activity query (`or[ and[contractID,
+  createDate in window], id in <the ticket ids the in-window time
+  references> ]` — an older or closed ticket carrying this period's time is
+  fetched, never reported as unresolvable) → the tickets
+  `entityInformation/fields` metadata read (the open-status picklist) → open
+  `Tickets` query (`status in` the open set) → resources (fetch-by-ids on the
+  distinct time-row `resourceID`s; skipped on none) → `ExpenseItems` query +
+  the ONE extra bounded miscoding probe (`TimeEntries` with `ticketID in
+  join` + `or[contractID noteq, contractID notExist]`; the join is the
+  fetched tickets whose record says THIS contract; skipped on an empty set)
+  → `ConfigurationItems` query (`contractID` = the CIs this contract covers,
+  never the whole company; default-on) → `Subscriptions` query (CI join;
+  skipped on no CIs) → the Subscriptions `entityInformation/fields` read
+  (the `status` + `periodType` labels; only when subscriptions came back).
+  Every window filter is `gte dateFrom` + `lt` the day
+  after `dateTo` (a datetime field keeps the last day's later rows). All
+  windows and month buckets are UTC days: date-only fields (`itemDate`,
+  units `startDate`/`endDate`) come back as UTC midnight (`Z`), datetimes
+  (ticket `createDate`) as UTC instants, and bucketing slices the ISO
+  string — in a UTC+10/11 tenant a ticket created late local time buckets
+  one UTC day (possibly one month) earlier than its local date. The
+  `time_entries.getPosted` / `getUnposted` endpoints are NEVER called (the
+  pinned vendor 500 on AU03); posted/unposted derives from the
+  `billingItems.timeEntryID` join (unposted = no billing item exists yet).
+  The structural exclusions (`/Services/`, `/ExpenseReports/`,
+  `/BillingCodes/` list reads, getPosted/getUnposted) are pinned by the
+  recorded-request test. Baseline = 12 (a resolvable contract); the
+  typical busy contract = 18; the full fixture = 20 (21 on a Block Hours
+  contract). `wires: { issued, requests, budget: 21, note? }` rides the
+  result as the honesty stamp: `issued` counts logical part reads (a
+  fetch-by-ids part counts once), `requests` the raw HTTP requests (its
+  chunk queries + per-id gets counted individually; a read-cache-served
+  contract `get` adds no request).
+- **Per-month windowing (parts `billingItems` + `timeEntries` +
+  `contractServiceUnits`).** One
+  full-window page (`MaxRecords: limit`); when it comes back FULL with a
+  live next cursor, the part re-queries PER CALENDAR MONTH intersecting the
+  window (one page per month, the date field bounded to that month, in
+  month order; rows deduped by `id`). A still-full month stamps
+  `hasMore`/`capped` + the truncation note (`month YYYY-MM hit the limit of
+  N — figures cover the returned rows only; widen with a narrower window or
+  higher limit`) — NO cursor walk (the house single-page rule; the composite
+  owns its own windowing so per-month figures stay correct by construction).
+  Every expansion read counts toward `wires.issued` (the note says why);
+  the 36-month cap bounds the worst case. A still-full month is also named
+  in that month's `coverage_gaps` (`<part>: truncated at limit N`).
+- **The cost-rate ladder (per time entry, zero extra wire).** Rung 1
+  `billing_item.ourCost`: a LINE cost, not a rate — Σ the finite `>= 0`
+  `ourCost` over the entry's billed lines (partial billing across months
+  sums naturally; an entry whose billed lines carry NO finite `ourCost`
+  falls THROUGH — the rung is unusable, not zero). Rung 2
+  `contract_role_costs.rate`: the `resourceID:roleID` row is preferred over
+  the role-only row (`matched: 'resource+role' | 'role'`); `rate × hours`.
+  Rung 3 `resource.internalCost`: the fetch-by-ids GET-fallback rows only
+  (a `NOT_FOUND` miss makes the rung unavailable for that resource — the
+  ww29 resources list-scoping is seen through by get-by-id, live-verified
+  2026-10-15; the quirk is cited in the part note when the chunk queries
+  0-rowed and the gets resolved). Rung 4 `provided`: `labourRatePerHour ×
+  hours` (in the ladder only when the rate is finite). `hours(entry)` =
+  `hoursWorked` when finite and `> 0`, else 0. A row resolving to
+  `missing` contributes 0 to `labour_cost.total` but is audited:
+  `costRateResolution.sources` (per-rung `entries`/`hours`/`cost`, ALWAYS
+  including `missing`), `unresolvedHours` (= the `missing` hours — the
+  lower-bound honesty number; `total_cost` is a LOWER BOUND exactly when it
+  is `> 0`), and the pinned note lines (the `N hours unresolved (missing
+  rate) — total_cost is a lower bound` line; the per-resource NOT_FOUND
+  line; the no-billing-item line). NEVER a silent zero. `contract_rates`
+  is NOT a ladder rung (the customer billing rate — the wrong side of the
+  P&L).
+- **Monthly P&L (one row per calendar month in the window).**
+  `revenue_invoiced` (Σ the line revenue of the month's items on
+  non-voided invoices; line revenue = `internalCurrencyExtendedPrice`,
+  falling back to `extendedPrice`) · `revenue_by_type { recurring, labour,
+  charges, expenses, other }` (the invoiced split, keyed on the verified
+  `billingItemType` picklist: 1 Labor / 2 Labor Adjustment → labour, 3 Cost
+  → charges, 4 Expense → expenses, 5 Subscription → other, 6 Recurring
+  Service/Bundle → recurring, 7 Recurring Contract Setup Fee → charges, 8
+  Milestone → other; an absent/unknown type falls back to the line's FKs in
+  the order `timeEntryID` → labour, `expenseItemID` → expenses, a charge FK
+  → charges, a contract service/bundle/period/adjustment FK → recurring —
+  labour billed against a service carries `contractServiceID` too, verified)
+  ·
+  `revenue_voided_excluded` (Σ on voided invoices) ·
+  `revenue_posted_uninvoiced` (Σ on posted items with no invoice yet) ·
+  `revenue_unresolved_invoice` (Σ on items whose invoice could not be read
+  or was beyond the join cap — not recognized revenue, never silent: the
+  month's `coverage_gaps` names `invoices: N line(s) on unresolved
+  invoices`) · `revenue_expected` (Σ the period `internalCurrencyPrice`
+  (fallback `price`) of the service units whose
+  period STARTS in the month — a multi-month period is counted once, when
+  it bills; `null` when the services/units basis is absent or the units
+  part is `absent` — unknown, not 0. Unit `price`/`cost` are PERIOD totals
+  (units × per-unit, prorated for a partial period — verified: the type-6
+  recurring billing item has `itemDate` = the unit `startDate` and
+  `extendedPrice` = the unit `price`). Units are normally one month but can
+  span a year; the start-month attribution matches billing, so the monthly
+  figures are a billing-period (cash) view, NOT accrual — an annual unit
+  lands in its start month in one lump) ·
+  `revenue_expected_unbilled = max(0, expected − the month's invoiced
+  SERVICE lines)` (labour and charges never mask a missed recurring
+  invoice) · `unposted_time { entries, hours, value, absent? }` (billable
+  time with no billing item yet — derived from the billing join, never
+  getPosted/getUnposted; `value` = Σ `hoursToBill ×
+  internalCurrencyContractHourlyRate` (fallback `contractHourlyRate`) on
+  Time & Materials contracts only, else `null` + `absent:
+  'NOT_TIME_AND_MATERIALS_CONTRACT'`, `'CONTRACT_TYPE_UNKNOWN'`, or
+  `'NO_CONTRACT_RATE'` when a role has no contract rate) · `labour_hours`
+  (Σ `hoursWorked` over positive entries — the same rule as the cost) ·
+  `labour_cost { total, unresolvedHours, rateSources }` (the per-month
+  mirror of the ladder audit) · `tooling_cost { vendor, caller_supplied }`
+  (vendor = Σ `periodCost × the periodType monthly share` — by the tenant
+  `periodType` LABEL (monthly 1, quarterly 1/3, semi-annual 1/6,
+  annual/yearly 1/12); a One-Time subscription is never prorated: its
+  `periodCost` is booked whole in its `effectiveDate` month; when the
+  Subscriptions catalog read fails, the verified id maps apply (periodType
+  1 One-Time, 2 Monthly, 3 Quarterly, 4 Semi-Annual, 5 Yearly; status 1
+  Active, 2 Cancelled, 3 Inactive) and the note says so; an unrecognised
+  periodType is excluded and named; only Active subscriptions count —
+  Cancelled and Inactive are excluded — over the subscriptions on this
+  contract's CIs active in the month, REPORTED ONLY:
+  never folded into `total_cost`, since subscriptions bill outside the
+  contract; `null` when the subscriptions part is skipped/absent;
+  caller-supplied = the bag value, `0` when absent) · `recurring_cost`
+  (charge COST — `extendedCost`, falling back to `unitCost × unitQuantity`
+  when it is absent or 0 while a unit cost exists; never `billableAmount` —
+  plus the `cost` of the units starting in the month, when included) ·
+  `expense_cost` (Σ `internalCurrencyExpenseAmount`) · `total_cost` (labour
+  + caller-supplied tooling + recurring + expenses) · `profit =
+  revenue_invoiced − total_cost` · `margin = profit / revenue_invoiced`
+  when `> 0`, else `null` (the division is refused, not zeroed) ·
+  `break_even_hours` (the labour hours the invoiced revenue absorbs at the
+  average resolved cost rate before profit hits zero: `(revenue_invoiced −
+  non-labour cost) / (Σcost / Σhours over resolved rows)`; `0` when the
+  non-labour cost already exceeds revenue; `null` with no resolved hours or
+  a zero rate — including an empty month) · `coverage_gaps` (why the
+  month's figures may be incomplete: `<part>: absent (<code>)` /
+  `truncated at limit N` / `capped at limit N` over units, charges, role
+  costs, billing, time, expenses and subscriptions, plus the unresolved
+  invoice lines; `[]` = complete). The P&L is single-currency in the
+  INTERNAL currency (revenue and costs alike); money fields are emitted
+  rounded to cents.
+- **The 11 data-quality checks (always present, order-stable, `count: 0` =
+  a passed check).** Typed `{ code, count, sample_ids }` warnings
+  (`count` = the full in-memory/fetched-set count, never capped;
+  `sample_ids` = first `limit`, deduped + sorted): `miscoded_time_out` (the
+  ONE extra bounded probe — time worked on THIS contract's tickets coded to
+  another contract or to none) · `cross_contract_ticket_time` (a fetched
+  ticket says it belongs elsewhere) · `duplicate_entries` (exact
+  `resourceID+dateWorked+ticketID+hoursWorked` tuple; `count` = all copies,
+  samples = copies beyond the lowest `id`) · `zero_negative_hours` ·
+  `time_outside_ticket_period` (`dateWorked < ticket.createDate` or after
+  the earlier of `resolvedDateTime`/`completedDate` — a fetched ticket's
+  whole post-resolution life, not just the first late entry) ·
+  `missing_cost_rate` (the ladder's `missing` rows; the resource NOT_FOUND
+  misses ride the note) · `recurring_cost_drift` (month-over-month beyond
+  the 0.005 float dust; samples the charge/unit ids whose monthly
+  contribution changed) · `expected_unbilled_revenue` (expected > the
+  invoiced service lines + 0.005; the pure "expected with nothing billed"
+  case carries the EMPTY sample — that is the assertion) ·
+  `cross_contract_tickets` (the
+  ticket-side drift + the entry-side unresolvable set) ·
+  `open_stale_tickets` (this contract's tickets; `now − lastActivityDate >
+  staleAfterDays`, `now` =
+  the run's wall clock stamped `period.asOf`; absent `lastActivityDate` is
+  unknown, not zero) · `estimate_vs_actual` (both estimates prorated to the
+  window — `estimate × overlapDays / termDays` over the contract term — and
+  flagged at `> 10%` deviation; samples `[contractId]`). 10 of 11 are pure
+  in-memory folds (zero extra wire).
+- **The response-side folds.** `activity_categories` (by `ticketCategory`:
+  hours, cost = labour + that category's expenses, ticketCount, entryCount,
+  sample ticket numbers) · `highest_cost_tickets` (cost desc, capped at
+  `limit`; a missing-rate ticket prices 0 and is flagged via the audit —
+  never silently dropped) · `possible_miscoding` (the probe rows + the
+  confirmed cross-contract entries, closed reason set
+  `no_contract_on_entry` / `ticket_of_other_contract` /
+  `ticket_not_in_fetched_set`) · `open_renewal_items` (this contract's open
+  tickets with the stale-days detail, subscription expirations with the
+  prorated monthly cost, the contract end, one `included_hours_burn` row
+  per purchased hour block) · `included_hours` (Block Hours contracts only:
+  `{ value: { purchased, approved, remaining } }` from the `ContractBlocks`
+  `hours` vs the vendor `hoursApproved`; any other contract type is `{
+  value: null, absent: 'NOT_BLOCK_HOURS_CONTRACT' }`, an unresolvable type
+  `'CONTRACT_TYPE_UNKNOWN'` — service units are a
+  quantity, never read as hours, and retainers are dollar-denominated).
+  The probe rows are EXCLUDED from the P&L folds (diagnostic — time not
+  coded to this contract).
+- **Degradation (per part typed `ok` / `blind` / `skipped` / `absent`; the
+  op NEVER fails the call on a degraded part).** Only the contract read is
+  fatal (the root: `NOT_FOUND` — or any other fault on it — propagates).
+  A vendor fault on any bounded list part degrades that part to `status:
+  'absent'` + `absent: <the typed error code>` + the note (never a true
+  zero — no `emptyReason`), and every monthly row it feeds names it in
+  `coverage_gaps`; a non-404 fault on the customer read degrades to
+  `customer: null` + `parts.customer: 'absent'` + `customerAbsent: <code>`.
+  Every tickets call is
+  `contractID`-filtered, so the pinned `unfiltered-blind` tickets class
+  never stamps a filtered empty (a filtered 0 is a TRUE zero with the
+  honest note); the 0-row parts carry the pinned
+  `tenant-empty-for-user` `emptyReason` stamp where attached. A dangling
+  customer FK (`companies.get` 404) degrades to `customer: null` +
+  `parts.customer: 'skipped'` — NOT an error (the CIs read still fires on
+  the contract row's `companyID`). A field-catalog fault degrades the open
+  pass to a typed skip (the fault read still counts in `wires.issued`).
+  fetch-by-ids per-item faults (invoices/resources) are typed partial
+  misses named in the part note — a miss never aborts the rest. An empty
+  tenant (the ww29 shape) degrades EVERY part — 13 wires, all-zero monthly
+  rows with the divisions refused (`margin: null`, `break_even_hours:
+  null`, `tooling_cost.vendor: null`, `revenue_expected: null`), all 11
+  warnings at `count: 0`, zero tool failure.
+- **0.12.1 corrections.** The 0.12.0 folds counted the charge
+  `billableAmount` (sell price) as recurring cost, read service `units` as
+  included hours, joined every company CI's subscriptions and added a
+  yearly `periodCost` every month, compared the expected recurring revenue
+  against all billed lines (labour included) and priced it at today's
+  `unitPrice`, read service units unwindowed, reported time on older
+  tickets as unresolvable, defined break-even without revenue, folded
+  expenses in their own currency, and threw on any bounded-part fault. The
+  bullets above are the corrected semantics.
+- **Registration surface.** The plan row (`capabilities.plan.json` →
+  re-derived hash) carries `kind: 'helper'`, `helperBasis: 'composite'`,
+  `effect: 'read'`, `dryRun: false`, the closed-bag `inputSchema` (the
+  signature-audited arg map in `scripts/lib/args-derive.mjs`); the emitted
+  method delegates to the hand-written special module
+  (`src/resources/special/contracts.ts`). The MCP projection serves
+  `autotask_contract_profitability` (catalog + manifest); the N8N
+  manifests legitimately EXCLUDE the op — `contracts` is not an n8n
+  curated entity (the curation rule is evidence-based: the daily support
+  subset is ticket/contact/company/resource/time_entry only).
+- **Test pins.** `test/resources/contracts.profitability.test.ts`: the
+  hand-computed 2-month synthetic fixture (every figure derived from the
+  fixture rows; `wires.issued = 18` with the exact queue; every wire pinned
+  in issue order; the structural exclusions + zero-mutating recorded paths;
+  the ladder audit incl. the per-month `rateSources`; the 11 checks with
+  exact counts/samples; the activity/highest-cost/miscoding/renewal folds;
+  the per-month windowing (exact extra month queries, id-dedup, the
+  still-full month note; `wires.issued` counts the expansion); the
+  join-set/`limit` caps; the malformed-bag refusal table (one complete
+  problem list, zero wire); the contract NOT_FOUND; the 0.12.1 pins: the
+  charge cost/period-type/line-type classifiers, the Block Hours
+  `contract_blocks` path, T&M unposted pricing + the time-referenced old
+  ticket, the exclusive window ends, the month-level `coverage_gaps`).
+  `test/resources/profitability-degradation.test.ts`: the empty-tenant
+  13-wire suite (every part degrades, zero tool failure), the dangling
+  customer FK, the non-404 customer fault (`absent`), a bounded-part fault
+  (`absent` + `coverage_gaps`, the call resolves), the resources blind-list get-fallback (rung 3 from the
+  gets, the quirk note), the per-item invoice fault (retries off — the
+  fault semantics are the pin, not the transport's 5xx budget), the
+  fieldCatalog-fault open-pass skip, the status-helper sentinel
+  portability (the `unfiltered-blind` predicate stamps the unfiltered call
+  only), and the §6.4 rate-ladder branch table over synthetic entry sets
+  (rung-1 line-cost sum, rung-1 fall-through, resource+role preference,
+  role-only, rung-3 get-fallback, the resource miss, the provided
+  catch-all/start, the provided-without-rate and fully-missing `missing`
+  — never a silent zero — and `internalCost: 0` as a RESOLVED zero).
+
 ## 12. Untrusted-content projection (issue #1)
 
 The agent/MCP projection marks EXTERNALLY-SOURCED free text as untrusted,

package/docs/N8N-ADAPTER.md

@@ -82,7 +82,7 @@ Two sources in, markdown table out: the node repo (the ops column is re-derived
 | `contractServiceUnits` | ContractServiceUnit | yes | get, getMany, count | — | count, get, getEntityInfo, getFieldInfo, getUdfInfo, query, resolve |
 | `contractServices` | ContractService | yes | create, update, get, getMany, count, createIfNotExists | createIfNotExists → `contract_services.createIfNotExists` | count, create, createIfNotExists, get, getEntityInfo, getFieldInfo, getUdfInfo, query, resolve, update |
 | `contractTicketPurchases` | ContractTicketPurchases | yes | create, update, get, getMany, count | — | count, create, get, getEntityInfo, getFieldInfo, getUdfInfo, query, resolve, update |
-| `contracts` | Contract | no | create, update, get, getMany, count, createIfNotExists | createIfNotExists → `contracts.createIfNotExists` | count, create, createIfNotExists, get, getEntityInfo, getFieldInfo, getUdfInfo, query, resolve, search, update |
+| `contracts` | Contract | no | create, update, get, getMany, count, createIfNotExists | createIfNotExists → `contracts.createIfNotExists` | count, create, createIfNotExists, get, getEntityInfo, getFieldInfo, getUdfInfo, profitability, query, resolve, search, update |
 | `countries` | Country | no | get, getMany, update, count | — | count, get, getEntityInfo, getFieldInfo, getUdfInfo, query, resolve, search, update |
 | `departments` | Department | no | count, create, get, getMany, update | — | count, create, get, getEntityInfo, getFieldInfo, getUdfInfo, query, resolve, search, update |
 | `domainRegistrar` | DomainRegistrar | no | create, update, get, getMany, count | — | count, create, get, getEntityInfo, getFieldInfo, getUdfInfo, query, resolve, search, update |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-autotask",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "description": "Fully-typed TypeScript SDK for the Autotask (Datto) PSA REST API. Zero runtime dependencies. Built for building MCP servers and integrations.",
   "type": "module",
   "sideEffects": false,