add_finishes
ChatGPTAdds one or many finishes to the shop's finish library (Settings > Finish colors) in one list. A finish is brand > line > color. Each: brand, line, colorName, finishType (stain, oil, paint or topcoat), optional code, sheens, legacyNote, productUrl, for paint the brand's published hex with hexSourceUrl, and makerSwatch or makerSwatches (the maker's photos, one per wood). A finish already in the library (same brand, line and color) is skipped. Inputs: finishes, source. Two steps: a first call returns a preview and a confirmKey and changes nothing; a second call with the same input and that confirmKey carries it out.
add_project_note
ChatGPTAdds an internal note to a job (the shop sees it, the client doesn't), such as a decision from a meeting or a size from the client's inquiry. Inputs: projectId, body.
build_builtin_plan
ChatGPTBuilds a built-in's parts model (bookshelves or cabinets along a wall, or an L around an inside corner, open or dead) from the shop's own numbers: runs (each wall, its sections and door sections), depth, height, top, base, face frame, shelves, counter, openings above it, doors (inset or overlay), wood, a rolling ladder. Returns each run's visible face with the corner taken off, every clear opening with the rails and shelf thickness taken out, what was checked, what's guessed and the self-check. Saves nothing.
build_table_plan
ChatGPTBuilds a table's parts model from the shop's own numbers, no listing needed: the base (leg_apron, four legs and aprons; splayed, legs splayed along the length; trestle, post-and-rail ends with a stretcher), size, topT, species, and change (tweaks in plain English: 'posts 3 1/2 square, add a mid rail, proud tenons 3/8'). trestle takes postsPerEnd, footLength and stretcherHeight; rods and cleat add turnbuckle rods from a center cleat; reading carries a reference reading (a listing and photos), as it came. Returns the model with finished sizes (tenons in rail lengths, long points on splayed legs) and dimensioned views, the parts in shop words, numbers.drawn (what the drawing shows view by view), rod runs pin to pin, what's guessed, changed (only what's in the returned model), unread, the self-check and the board feet so far. Saves nothing.
builtin_takeoff
ChatGPTThe board takeoff for a drawn built-in in the shop's own boards: usable width after jointing, edge glue-ups for wide parts, resawn backs, waste on top. Inputs: projectId, planId, board {width, length, thick}, usableWidth, wastePct, pricePerSqFt, addToList (puts the buy on the job's estimate). Orders nothing.
calc_board_feet
ChatGPTBoard feet for lumber pieces, the same math as the app's Board feet calculator. Each piece: thickness (inches like 0.75 or '3/4', or quarters 4/4 to 32/4), width in inches, length (feet by default, or lengthUnit 'in') and quantity. Optional wastePct and pricePerBoardFoot give a total cost.
calc_measurements
ChatGPTTape-measure math with fractions ('3 1/2 + 7/8 x 2', '96 - 2 x 3/4', '25mm'). Input: expression. Returns the fraction, the decimal, the nearest 1/16 and millimeters.
calc_rough_lumber
ChatGPTRough hardwood worked back from finished sizes: for each part, the finished thickness plus the shop's milling allowance gives the smallest quarter that covers it (1 1/2 + 1/4 = 1 3/4, so 8/4), or the shop's glue-up rule for thick parts, with the rough size, board feet per part, the total, waste as its own line, and cost from the Price Book's per-board-foot items. Inputs: species, parts (finished sizes), wastePct. Returns ask when a width or length is missing, and howToSay, the part-by-part wording.
calc_sheet_count
ChatGPTHow many sheets (plywood, MDF) a list of parts needs, packed the way the cut planner packs them. Each part: length and width in inches, quantity, optional grain ('length' or 'width'). Sheet size defaults to 48 x 96 in with a 1/8 in blade; sheetWidth, sheetLength, kerf and pricePerSheet are optional.
check_bought_boards
ChatGPTPlans a cut list on the boards actually bought ('2 x 1x10 x 16'', rough '8/4 White Oak, 8 wide, 10'', a named one-off board) with the cut planner's nesting and rips, saving nothing: the parts spread over the boards, then narrower parts of the same thickness ripped from what's left (fromRemainder, on by default), and a material that came out of the remainder dropped from the shopping list. Inputs: projectId, bought, and parts (as confirmed) or planId or cutPlanId or documentId; fromRemainder, offcutsFirst, remainderParts. Returns preview (each board, the parts cut from it and what's left after them), moved (each part once, under the board it comes from), the shopping list and problems (parts that won't fit what was bought).
check_parts_plan
ChatGPTThe self-check for a parts model before it's drawn, saving nothing: dimensions tie out against the parts, chains add up end to end, nothing overlaps (mitered corners and allowed joints aside), and every part fits its stock. Inputs: projectId, what, model or table (a table's short spec), basedOnPlanId, change, listUnconfirmed, beyondTable. Returns problems, questions, fits, the top open question (ask, with recommended and why; asksLeft), the shop's rules, and addedDims, the sizes added to each view from the parts. A hand-written table model is refused unless it has something the table model can't build (steel, a shelf, drawers, an X base) or beyondTable says what.
check_plan
ChatGPTWorks out a frame's sizes from the gear and the shop's sizing rules, saving nothing: outside W x H x D, inside W x H, the stacked height breakdown, warnings (depth to the floor, a tall soundbar, missing specs, two different TVs, heat near a fireplace or stove) and what still needs confirming. Inputs: projectId, what, items, overrides (this drawing only, e.g. sideClearance and topClearance), near. Not for structural or code work (stairs, railings, beam spans, wall-mount ratings).
check_price_book_items
ChatGPTWhat saving these prices to the Price Book would do, writing nothing: each item added, or the existing one updated ('White Oak 8/4 $14 -> $7/BF'), no duplicates. Input: items.
correct_plan
ChatGPTApplies a plain-English correction ('legs 3 x 3', 'top 1 3/4 thick', 'add a mid rail', 'legs splay 8 degrees', 'proud tenons 3/8', 'no breadboard ends') to a job's latest drawing version, or planId. Inputs: projectId, planId, change. Returns the new parts model, what changed, and anything it couldn't read. Saves nothing.
create_automation
ChatGPTBuilds the automation from a saved draft plan, by its planKey: exactly the plan as drafted, switched Off, so nothing goes to a client until the owner turns it on in Square Away. Works only for a plan drafted for this shop, and only once per plan; a second call with the same planKey returns the automation already built. New emails are saved to the shop's email templates. Input: planKey. Returns the automation's name and a link to open it.
create_contact
ChatGPTCreates a contact and a starter job in the first pipeline stage, the same as adding a contact on the Contacts page. Inputs: name, email, phone, company. Sends no email or text.
create_draft_proposal
ChatGPTSeveral steps in one approval: adds a new client (newClient) or uses an existing one (contactId), starts a job (or uses projectId, with projectName for a new one), adds each item to the job's estimate with its quantity and its cost and sell price for one (clientChoice items are optional add-ons under a parentItem, outside the total until the client picks them), and makes a DRAFT proposal from the job's whole estimate. Returns proposalLines (every line on the draft, including any the job already had), totalBeforeTax (the sum of those lines), and alreadyOnJob when earlier lines came along. Nothing is sent to the client.
create_lead_form
ChatGPTBuilds a new lead form as a DRAFT (not live) for the shop to review and publish. Every form starts with a name and email block. Inputs: name, headline, subheading, signupOnly, thankYouMessage, questions; question types are shortText, longText, phone, address, dropdown, singleChoice and multipleChoice (each with options), date, number, link and fileUpload.
design_packet_status
ChatGPTWhere a job's Design Packet stands: ready, sent and waiting, approved (who, when), or changes asked for, with the finish option the client picked and the ones shown but not chosen. Input: projectId.
draft_estimate_from_plan
ChatGPTPuts a drawing's materials on the job's estimate as DRAFT lines: the cut list's boards and sheets priced from the Price Book, the shopping list's hardware (at $0 when it isn't in the Price Book), each outsourced assembly as one Outsourced line, beams used whole by the foot, a Finish line from the shop's finish settings or what the owner said, and Install labor for delivery. Makes the cut list first when there isn't one. Inputs: planId, and finishHours, finishCost and deliveryHours as the owner said them. Makes no proposal and sends nothing.
draft_payment_reminder
ChatGPTWrites a payment reminder for a client's open payment in the shop's own reminder words (Settings > Shop defaults), with the real pay link. Inputs: projectId or contactId, and scheduleItemId once a payment is picked. Returns choose (the open payments) when there are several, or card (the reminder, ready to send) when there is one. Sends nothing. Shop owner only.
draft_proposal_description
ChatGPTDrafts a proposal line's description from a drawing (the approved version, else the latest, or planId) in the shop's own voice: by default warm paragraphs, an Included: list, the timing and a thanks to the client (style 'bullets' for a list). The drawing's facts are used with every vendor name, cost and lead time taken out. Inputs: projectId, planId, itemName, style, extra (what the owner wants said that the drawing doesn't show). Saves and sends nothing. Uses one AI action of credits, only when a draft comes back.
draw_plan
ChatGPTMakes and saves a job's dimensioned frame drawing as its next version (v1, v2...) in the Design tab under Plan drawings: title, front and side views, notes, and a 'Please confirm' box listing every item and where each number came from (spec_sheet, maker, client or assumed). Inputs: projectId, what, items, overrides, near. Missing numbers show as please confirm, except the main item's width and height. Also drafts an email and a text to the client with the drawing; nothing is sent.
find_jobs
ChatGPTFinds jobs (projects) by loose words: the job's name or the client's name, e.g. 'Smith dining table'. Input: query. Returns the best matches with projectId, client, stage and due date.
find_maker_swatch
ChatGPTFinds the maker's own photo of a finish color on their site (General Finishes per-species chips, Rubio Monocoat swatches, or a page link). Inputs: brand, line, colorName, species, url. Returns each photo with the wood it's shown on as the maker states it ('on red oak'; General Finishes 'on oak' means red oak) or 'species not stated', and Legacy or Discontinued when the maker lists it so. Saves nothing.
finish_approval_status
ChatGPTWhere a job's Finish & Wood Approval stands: not sent, ready at the visit, sent and waiting, or signed (who, when, how), and which selections are client approved. Input: projectId.
fit_rod_kit
ChatGPTWhich turnbuckle rod set fits each rod run. Inputs: runs (pin-to-pin lengths), kits (the set lengths a hardware page lists; only these are picked from), morePages, host (the maker's site, for its sizing), inputs (the drawing's A, B, C, D, for the maker's own calculator, whose run is used when given). Returns the set that fits, a tie between two, or how far too short or too long the listed sets are, with the numbers, and any listed size outside the maker's range. Read only.
get_client_messages
ChatGPTThe latest emails and texts with a client, both directions, newest first. Input: contactId, or a name or email in search.
get_commissions_owed
ChatGPTTeam commissions owed: each salesperson's unpaid commission and the next pay day. Available to the owner or a team member with money access. No input.
get_cut_list_parts
ChatGPTThe parts a job's cut list is made from, for re-planning on the boards actually bought: from a drawing (planId), a saved cut plan (cutPlanId), or an uploaded cut list photo or PDF in the job's Files (documentId; reading it uses one AI action of credits, only when parts come back). With only projectId it takes the newest source. Returns parts (structured, rough hardwood pieces included), lines (the same in shop words), the stock, unclear, and uploadedCutLists. Read only.
get_held_automations
ChatGPTAutomation steps held for the owner's review (an email, text or stage move), each with its job. No input.
get_job_facts
ChatGPTEverything written on a job, best matches for a question first: project notes, the contact's notes, lead form answers, estimate and proposal lines, emails and texts, and calendar meetings, each with its source and date. Inputs: projectId or query (job or client words), and question. Also returns heads-ups when the notes are older than the latest meeting or message, and when sources give different sizes.
get_job_materials
ChatGPTThe materials a job needs: its estimate's material lines (description, quantity, unit, unit cost, waste %, the Price Book item and price) and its saved cut plans (sheets and boards to buy). Inputs: projectId, and an optional search such as '3/4 finished ply'. Each number comes with where it came from.
get_job_money
ChatGPTA job's money: each proposal (number, status, total, viewed and answered dates), each invoice, what's paid, the open balance, what's overdue and what's due next, and payLinks, each open payment's client pay link. Input: projectId. No payLinks means no open balance.
get_my_commissions
ChatGPTThe signed-in person's own commission: earned this month, quarter or year (period), what is owed to them and the pay day, how close the next tier is, and each of their jobs with where it stands. Only the signed-in person's own figures; no job prices, costs or profit.
get_next_start
ChatGPTWhen a new job could start, from the shop's production queue. Input: buildDays, the job's build time in shop days (10 for a 2-week built-in). Returns the projected start week, the projected finish and the reason; small jobs can fit in sooner as fillers.
get_pipeline
ChatGPTEvery pipeline stage and the projects currently in each one: the current state of the shop's sales and production pipeline. No input.
get_plan_drawing
ChatGPTA job's plan drawing versions (with which is client approved), and one version's parts model (the latest, or planId), with stockNow (how each rough part is got today: glue-up or one board) and millTrip (the saved mill trip's boards). Inputs: projectId, planId. Superseded versions are archived and read only.
get_price_book
ChatGPTSearches the shop's Price Book: sheet goods (price per sheet and size), edge banding and other consumables (per linear foot, square foot, board foot, each, or a flat price) and hardware, with the vendor and when each price last changed. Inputs: search, limit.
get_project
ChatGPTFull detail on one project: contact, stage, due date, tasks and recent notes. Input: projectId.
get_proposals
ChatGPTProposals across every job, newest first, with status (draft, sent, accepted, declined, changes_requested), total, and when each was viewed and answered. Inputs (optional): status, projectId, limit.
get_recent_leads
ChatGPTNew leads and inquiries from recent days, newest first: name, email, phone, where each came from (a lead form, a Facebook or Instagram lead ad, a scheduler booking, or an Auto DM from a comment keyword), when, and the job's stage now. Inputs (all optional): days, source, limit, form, search.
get_schedule
ChatGPTThe shop's schedule for a stretch of days (days; default today and the next 6): bookings, meetings, tasks due and job due dates, in the shop's time zone.
get_shop_money
ChatGPTMoney owed to the shop across all jobs: open and overdue invoice payments, unpaid deposits, and proposals sent and waiting (or with changes asked), each with its job and client. No input.
get_shop_precedents
ChatGPTHow this shop already does something (a base, joinery, a stretcher, hardware, a size): matching Price Book items, the same choice on its past drawings (job, version, part sizes, shopping list lines), its saved rules and its usual apron size. Input: about, the thing asked about; shop synonyms are matched too (a turnbuckle finds rod kits, rod ends and clevises). Read only.
get_social_posts
ChatGPTThe shop's social posts in three lists: upcoming (soonest first), recentlyPosted (newest first) and failed (with the problem), each with its time in the shop's time zone and day. Inputs (optional): status, daysAhead, daysBack, limit.
get_tasks
ChatGPTOpen tasks: overdue, due in the next days (days), and with no due date, each with its job. Bookings are not included.
list_contacts
ChatGPTLists this shop's contacts. Input: an optional search term matched against name, company or email. Returns each contact's name, company, email, phone and id.
make_cut_list
ChatGPTMakes and saves a drawing version's cut list as a cut plan on the job, with the shopping list priced from the Price Book: rips out of posts and boards, crosscut first, miter allowance, profiled stock and sheet goods. Rough hardwood is listed piece by piece (quarter and species, milled-to size, glue-up layers, long points), and planned on the drawing's saved mill trip boards when there is one. Input: planId. Returns the saved block read back from the stored plan (piece count and board feet), or an error when no cut list was made. After an approval, it notes when the materials price moved.
open_page
ChatGPTA link to one page of a job. Inputs: page (job, details, activity, files, estimate, quick_estimate, payments, expenses, tasks, notes, photos, shop_ticket, shopping_list, cut_plan or automations) and projectId. Returns openUrl, a full link into Square Away.
prepare_builtin_approval
ChatGPTMakes the client's approval sheet for a drawn built-in as a PDF in the job's Files: the installed 3D views, both fronts, the plan and the side, heights and widths in friendly words, and one choice for the client (shelf spacing by default, or the choice given). Inputs: projectId, planId, choice {question, options [{label, detail}]}, noChoice. Sends nothing; the client's pick is saved with the approval.
read_maker_colors
ChatGPTLists every color on a maker's color page, grouped by product line, each with the maker's photo for each wood it's shown on ('on red oak'; General Finishes 'on oak' means red oak). Input: url, or brand alone for a maker whose pages are known (General Finishes: its Water Based Wood Stain and Water Based Dye Stain pages). When the maker's site doesn't answer, a known page's colors come from a saved copy, marked fromSavedCopy with its date. Saves nothing.
read_reference
ChatGPTReads a piece the client wants built: a product link and every photo on the job (job photos, files, pictures the client texted or emailed, lead form photos). The page is fetched on the server (https, public sites only) and only its text, listed sizes and photos are read. Inputs: projectId, url, photoIds, question, closeLook. Returns what it is, listed sizes, each construction detail as seen (with its photo) or guessed, the legs' lean (legAngle, with confidence), close-ups worth asking for, and with question an answer with its confidence. Follows a store page a few pages (page.pages). Retailer photos are read, not saved or sent. Uses one AI action of credits, only when the read works.
read_spec_photos
ChatGPTReads a job's photos (job photos, image files, pictures the client texted or emailed) and recent messages for spec sheets and store tags of the gear a frame goes around (TV, soundbar, subwoofer, fireplace insert, appliance). Input: projectId. Returns each item's brand, model, and width, height, depth, weight and VESA, each marked spec_sheet (printed on a photo) or missing (null). No web search. Uses one AI action of credits, only when gear is found.
rebuild_build_packet
ChatGPTRebuilds a drawing version's build packet from what's saved for it now (its cut list, the rough lumber piece by piece, and its rough board plan) as a new packet version; the old one is kept and marked superseded. A packet with no cut list says so. Inputs: planId, label. Owner only.
recommend_automation
ChatGPTDrafts a recommended automation for a goal in plain English ('follow up with anyone who goes quiet after an estimate'), from the shop's real stages, email templates, session types, lead forms and team: the trigger, waits, checks, emails and texts, stage moves, tasks, the end conditions (a reply, a booking, a stage change) and a final what's-next task. Emails with no matching template are written new; anything the shop doesn't have is listed as missing. Inputs: goal, and change with planKey to revise a plan already drafted. Saves nothing.
remember_varies
ChatGPTRecords that a build choice (thick parts, base wood, joinery) varies job to job for this shop, so the 'standard or varies?' question isn't repeated for that topic. Input: topics. Not a shop rule; changes no drawing.
replan_bought_boards
ChatGPTSaves a cut list re-planned on the boards actually bought (the same input as the bought-boards check, plus its preview): a new cut list version on the job (board-by-board bars, remainder strips as their own rows), the old one kept and marked superseded (off the shop ticket and the Shop TV), the cut list picture in Files, and the shopping list and estimate lines updated (the bought boards in, what's no longer needed out). Returns the saved block, read back from the stored plan.
resize_reference
ChatGPTResizes a piece read from a reference listing and photos to the customer's size the way a woodworker would: lumber sections keep their real sizes, long parts grow, boards are re-counted to even widths, overhangs stay sensible, and anything the new size breaks is flagged (a sagging shelf gets a center support). Tables use their own models (an X base, four legs and aprons, splayed legs, or post-and-rail trestle ends; modelChoice says which and why), and ask comes back when the reading can't tell the base. Inputs: projectId, reading, size, base, model (the original's parts model, for anything that isn't a table). Returns the resized parts model with every size tagged seen, scaled or guessed, the flags and the self-check. Saves nothing.
save_plan_rules
ChatGPTSaves answers the owner gave as the shop's own drawing rules (Settings > Estimator > Plan drawings), used on every drawing from then on. Input: rules. Two steps: a first call returns a preview and a confirmKey and changes nothing; a second call with the same input and that confirmKey carries it out.
save_price_book_items
ChatGPTSaves prices to the shop's Price Book: rough hardwood by species and quarter per board foot, beams and linear stock per foot, sheet goods per sheet, and bought parts each, with the vendor (found by name, or added). An existing item is updated, not duplicated. Inputs: items, preview, and projectId or planId to re-cost that drawing's rough lumber, mill trip and draft estimate lines right after. Owner only. Two steps: a first call returns a preview and a confirmKey and changes nothing; a second call with the same input and that confirmKey carries it out.
send_payment_reminder
ChatGPTSends a drafted payment reminder card, word for word as drafted, through the app's Request payment: a branded email with the pay button, and a text too only when the client agreed to texts. Inputs: the card's fields (scheduleItemId, client, job, payment, amount, dueDate, due, overdue, channel, emailTo, textTo, emailOnlyBecause, subject, message, textMessage). Two steps: a first call returns a preview and a confirmKey and changes nothing; a second call with the same input and that confirmKey carries it out.
send_to_tv
ChatGPTShows something on the Shop TV now, the same as the app's Send to TV: a cut plan (cutPlanId, held on screen until cleared), a job file such as a cut list picture or a drawing (documentId), or a job's whole package (projectId, with focus cutlist, materials or notes). Goes to every paired TV, or the one named (tv). Superseded cut lists and archived versions can't be sent. Inputs also include label.
set_fact
ChatGPTWrites the owner's answer to one open question (askId, as a drawing check or correction returned it) into the parts model: a tube's wall, a measured beam size, the finished height, a hole OK'd, an assembly's finish, lead time or price, a beam's price per foot or species. Inputs: model or projectId (the latest drawing) or planId, askId, answer, and the standing-rule flag (true when the owner said it's how they work on every job). Returns the model, what was written, the next open question, and rememberRules when that flag is set. Saves nothing.
set_job_finish
ChatGPTSets a job's stain or paint from the shop's finish library on its Design tab Selections (with the real swatch for the job's wood), plus the sheen and the topcoat sheen. Inputs: projectId, finishId or colorName (with line or brand), where, sheen, polySheen, species; colors the shop marked as in use match first. Owner only.
set_on_shop_ticket
ChatGPTPuts a job file (a picture or PDF, such as a cut list or a drawing) on the job's shop ticket, or takes it off (on: false). Turning on a newer version takes older versions of the same file off; the result lists them. Archived versions can't go on. Inputs: documentId, on, label.
show_howto_video
ChatGPTFinds one of Square Away's walkthrough videos (about 6 minutes each) on a topic such as brand and logo, payments, the price book, estimator settings, calendar and booking, cut lists, the Shop TV, lead forms, emails and newsletters, automations, the client portal, team and notifications, social, importing, proposals, templates or the production board. Input: topic. Returns the video's link and its numbered steps, comingSoon when it isn't recorded yet, or the list of topics when nothing matches.
