LabWired

Draft an AI-generated, not verified I2C part pack (type ai:<slug>, source ai-draft) for a catalog miss. Not for MCUs; register maps are only as good as the facts supplied. Set registers[].source (e.g. temperature) to expose a SimInput/stimulus channel. Smoke-checks the pack; returns `pack` (for diagram.partPacks) and `pack_yaml` (text). Not added to the catalog.

labwired_draft_i2c_part

Draft an AI-generated, not verified SPI part pack (type ai:<slug>, source ai-draft) for a catalog miss. Not for MCUs; register maps are only as good as the facts supplied. command_byte mirrors the engine SpiFraming struct; set registers[].source to expose a SimInput/stimulus channel. Smoke-checks the pack; returns `pack` (for diagram.partPacks) and `pack_yaml` (text). Not added to the catalog.

labwired_draft_spi_part

Apply exact-string replacements to a saved project's firmware, in order. A missing or non-unique match is refused with applied:false, source_unchanged:true and the current bytes: a failure to act on, never "no edit needed". Signed-in users only, not API keys.

labwired_project_edit_firmware

Export a diagram to a PCB layout tool in one of the `format` values. The artifact is a projection of connectivity, not a verified board: it states what is wired to what and does not mean the circuit works, that the copper can be routed, or that anything was simulated. `warnings` lists parts with no footprint (imported as unplaceable) and parts the catalog does not know (omitted from the artifact).

labwired_export

Run KiCad DRC on a stored PCB board and, only if it passes, return signed links to gerbers, drill, positions, BOM, bom_jlc.csv, cpl_jlc.csv, board.step and the zip; a failure returns the KiCad findings and no files. The board is not changed. A status=running reply carries job_id; repeat with it.

labwired_pcb_export

Flash firmware onto the bench board (probe-attached target) in the caller's signed-in Studio Hardware dock, overwriting its image. The page confirms; the call may return confirm-required with a job_id whose state settles to succeeded, failed, cancelled or timed_out. Give a firmware_ref (sha256:<64 hex> or an http(s):// URL the page can fetch) or inline `image_base64` + `name`; `format` defaults to the name suffix (elf/bin/hex). Rate-limited per account.

labwired_device_flash

Read one saved project: board, diagram, firmware, stimuli, content_hash, PCB link, evidence, requirements with status verified|failed|stale|unverified. revisions:true lists revisions instead. Signed-in users only, not API keys.

labwired_project_get

Halt the target CPU of a bench or debug session.

labwired_device_halt

Build one LabWired hardware lab and return a Studio URL (`open_url`) plus an inline lab widget. Omit `diagram` for a validated LED-blink starter on `board`; pass `diagram` for a custom circuit. For PCB work, use the combined viewer. Arduino-framework boards: language arduino (cpp, c++, ino normalize). Returns `open_url`, `build_status` (ok|failed|skipped|pending), `simulation_status` (ready|not_run|failed), `preview` and `compiler_errors`. Pass precompiled `firmware_ref` / `flash_image_refs` from an earlier compile to share exactly that build. Creates a shareable lab each call.

labwired_lab

Import circuit source into a design pack and optional twin. source_kind=diagram_json|kicad_sch|kicad_pcb|netlist|altium_pcbdoc|altium_schdoc (twin), bom_csv|text|pdf_text (design context + catalog map). netlist = a KiCad `.net` (5-9) or an Altium/Protel `.net` (auto-detected), returning an import `report` (simulated vs inert parts, dropped pins, runnable); kicad_pcb = a `.kicad_pcb` alone (pads carry the exact netlist); altium_pcbdoc/altium_schdoc = Altium files (OLE2 or an ASCII export, `.PcbDoc` and `.SchDoc`; `encoding: base64` for OLE2) whose connectivity comes from the file itself or, for a `.SchDoc`, from the `companion` `.PcbDoc`. Pins are never invented; unmapped parts go to diagram.coverage (verification reports them as unproven). twin_buildable only if the catalog mint succeeds. Returns the design pack and next[].

labwired_import

Inspect the live debug state of a session: an opted-in hardware bench, or a headless debug session (hosted; twin ids "dbg_", board ids "bench_"). Board access needs an open Hardware dock session. `what` selects the slice: "memory" uses `address` (and optional `length`); the other values ignore them. Read-only.

labwired_device_inspect

Read a stored PCB board without changing it. query: ratsnest (unrouted links), drc, net (needs `net`), region (needs bbox:[x1,y1,x2,y2]) or parts. rev defaults to the latest. Units mm, origin top-left of the board outline, y down.

labwired_pcb_inspect

Read stored run `snapshot_id`: registers, framebuffers, serial, gpio edge traces and diagnosis. `output`: summary|serial|peripherals|full|trace; `peripheral` filters registers. Hosted trace reads a pin waveform (see detail).

labwired_inspect

List real boards connected to the caller's signed-in Studio Hardware dock. With no bench, the error includes connect_url and instructions: open https://app.labwired.com/?connect=debug, sign in with the same LabWired account, click Connect, select the probe, and keep the page open. Each bench carries its sessionId, probe, transport, optional board and firmwareName, and lastSeenMs. Read-only.

labwired_device_list

List the LabWired catalog. `kind` selects "board", "mcu", "component", "input", "lab", or founder-authorized "chip". Omit it for boards, labs, and components. Optional `filter` matches id/type. Returns basic rows; use labwired_describe for details.

labwired_list

List your saved LabWired projects. Filter by name with q; page with limit and offset. Signed-in users only, not API keys.

labwired_project_list

Order the parts of a BOM: prices it like labwired_price, stores an order and returns `estimate`, the priced `lines`, `unsourced` lines and a `payUrl` for the user. The price is an estimate confirmed by a person; the card is only held until then, and each seller ships to the user. `unsourced` lines have no seller price and are the user's to buy. Or `board_id`: JLC fab + assembly + parts, at published prices.

labwired_order

Look up a part or MCU by MPN, alias, family, or catalog spelling. Returns what is known, graded by backing, from separate sources never blended or summed: (1) cross-checked facts: a datasheet quote AND the executable model agree; (2) `vendorClaims` (VENDOR_ONLY): vendor CMSIS-SVD register or pin map, assurance "vendor-claim", not a fact; (3) `modelClaims` (MODEL_ONLY): LabWired's pin model, assurance "modelled", pin names/roles for every catalog part and board, true of the twin, not a datasheet; (4) `quotes` (NOT_EXTRACTED): the held document's lines on the question with pages; citations, not facts. Omit `query`/`configurationId` to list the corpus (curated parts then vendor-SVD devices), 25/page; `nextCursor` feeds `cursor`. `predicates: ["pin.function"]` asks for pins; a part no source describes is REFUSED, never an empty body. Pass `peripheral`, `register` or `address` for the SVD register map; registers ONLY; package/electrical questions return WRONG_SOURCE. A reset value not marked `stated` is a file-wide default and may be wrong. Also returns `modelConflicts` (document and model disagree) and `ambiguities`. `lanes` reports what each store held: held / empty / refused / unavailable. Missing data is absent, not invented: an empty bucket is unknown, never zero. A miss is recorded as demand.

labwired_part

Move parts on a stored PCB board. Needs the current rev; returns rev+1 with a report: nets complete, unrouted links, new violations. Moving a part deletes the tracks, vias and zones touching its pads and lists them in report.deleted. Units mm, origin top-left of the board outline, y down. rot degrees CCW.

labwired_pcb_place

JLCPCB/LCSC prices and live stock; other sellers require server enablement (`providersUnavailable`). `part` is a catalog type, MPN, or part name; the sellers search. `quantity` is how many devices are built; a rung is read at quantity x count. `total` is null unless every line priced in one currency; priced lines are still itemised, unpriced ones listed with reasons. `matched`:"family" is a package variant of the right chip (tmp117 -> TMP117AIDRVR): an estimate, not a quote, and any such line makes `total.basis` "family-estimate". No unpriced reason is a zero price. Read-only.

labwired_price

Publish a saved project to the public LabWired community feed. Refused unless you own it, it currently passes verification and it is not a byte-for-byte unmodified fork. Signed-in users only, not API keys.

labwired_project_publish

Store firmware source files as content-addressed source artifacts and return a compact source_tree_ref (`sha256:<hex>`). The ref is accepted wherever firmware source is taken, so large sources need not be resent.

labwired_put_source

Read the console output of one opted-in hardware bench with a cursor, like tailing a serial log. Needs an opted-in Hardware dock session. Returns the entries after `cursor` (up to `limit`) plus the cursor to pass on the next call; the bench keeps only a bounded tail, so older entries may already have been evicted. Read-only.

labwired_device_console

Read a part's manufacturer datasheet as text, page by page. No arguments lists every datasheet held. `part` + `search` returns pages mentioning a register, pin, command or timing parameter (BM25-ranked, full text of the top pages). `part` + `pages` returns those pages verbatim. `matches` is a relevance score, not a count, and a "terms" hit only means the words appear on the same page. No hits means the document lacks the query, not that the part lacks the feature; vendor wording varies. A search spans the part's documents (datasheet and reference manual); each hit names its `document`, which can be passed back as `part` to read on. In `lanes`, `empty` is a document not held and `unavailable` one held but not searched. Raw document text only, not cross-checked against an executable model. Read-only and stateless.

labwired_datasheet

Reset the target, discarding its running state.

labwired_device_reset

Add or delete copper on a stored PCB board: ops:[{op:"track",net,layer,points:[[x,y],…],width?} | {op:"via",net,x,y} | {op:"zone",net,layer:"F.Cu"|"B.Cu"|"both"} | {op:"delete",ids:[…]}], e.g. ops:[{op:"track",net:"GND",layer:"F.Cu",points:[[10,5],[20,5]]}]. Ops apply in order, each seeing the earlier accepted ones; a short or clearance violation rejects that op, says why and where, and changes nothing. Needs the current rev; returns rev+1 with a report: nets complete, unrouted links, new violations. Units mm, origin top-left of the board outline, y down.

labwired_pcb_route

Flash firmware onto an opted-in hardware bench (the probe-attached target board, overwriting its current image), boot it, and monitor RTT/defmt + semihosting for a bounded window. Needs an open Hardware dock session. The page handles the confirmation handshake. Takes the same firmware inputs as a plain flash; `monitor_ms` caps the monitoring window (default and maximum 120000). Rate-limited per account.

labwired_device_run

Run firmware in the LabWired digital twin against a virtual hardware diagram. Observational: reports what happened, never mints a "verified" badge. Firmware comes from `source_tree_ref` or a small `source` with explicit `board`, `language`, and matching `entryPath` (compiled on the hosted toolchain, no local compiler), or from a precompiled `firmware_ref` + `target`. Returns status, serial, cycle counts, the peripheral inspect wall (decoded registers + display framebuffer artifacts), a `snapshot_id` identifying the stored run state, and, on fault, hang, or step limit, a hardware-level diagnosis. Unmodeled hardware access is a fault (fail-loud). May return {status:"running", run_id} for long runs; call again with just `run_id` to collect it. Targets: Cortex-M (STM32, RP2040, nRF52) bare ELFs, ESP32-C3/S3 ROM-boot images, classic ESP32.

labwired_run

Find real, buyable JLCPCB/LCSC parts by category and params, e.g. "ldo", {"vout":3.3,"iout_min_a":0.3}, package "SOT-23-5". Ranked: in stock at in_stock_qty, basic/preferred, price. `part` feeds labwired_price/labwired_order; `catalog_type` is the diagram part if any. `matched_on` splits seller vs local filters; `notes` names any filter not applied as asked. Empty is not proof no part exists. Read-only.

labwired_part_search

Search the LabWired MCP tool catalog by keyword and return matching tool definitions, including extended per-tool reference notes. Covers board/component discovery, diagram validation, firmware compile/run/verify, inspection and hardware-lab tools.

labwired_search

Session design context: design_context_ok (design can continue), twin_buildable (a twin can be built now), next[] (next steps) and the served schema revision. Optional `goal`, `project_id` and pack inputs shape it. Only an oracle-gated verification run sets model_verified. Call it first. Hosted loop: parts, firmware, verify, PCB, export, order.

labwired_context

Check that the copper on a stored PCB board builds the circuit its diagram describes: runs the firmware on both and compares. verdict equivalent, different (first difference) or inconclusive (a run timed out, did 0 cycles or gave no signal; never a pass). Firmware inputs as in a simulator run. A long run returns status=running and job_id; repeat with it.

labwired_pcb_simulate

Start a headless debug session on the digital twin (builder host) for a symbol-bearing ELF. It starts halted at entry and returns a session id (twin ids start with "dbg_") accepted by the session control, inspect and stop tools. Supports source breakpoints and stepping; address breakpoints, register/memory writes and reset are out of scope on twin sessions. Set target_kind="board" to debug the probe attached in the Studio Hardware dock instead: the session id starts with "bench_" and `diagram`/firmware inputs are not required (the board is already flashed). With no bench attached it returns a connect_url to open with the same LabWired account, Studio kept open. Sessions expire when idle.

labwired_debug_start

Single-step the target: one instruction, or one source line with step_mode (twin).

labwired_device_step

Close a headless debug session by its session id. Twin sessions terminate their labwired-dap child; board sessions release the session record and leave the probe attached to the dock. Safe to call after a lost or expired session (returns already-closed).

labwired_debug_stop

Take a saved project off the public community feed. The project itself is kept. Signed-in users only, not API keys.

labwired_project_unpublish

Validate a Playground diagram (ERC + pin checks) and/or check firmware-to-wiring consistency (does the firmware drive the pins the diagram actually wired?). Returns diagnostics with error/warning counts; errors mean the diagram is not wired correctly.

labwired_validate

Mandatory-oracle model-verification gate: run firmware and classify it against an explicit behavioral oracle. model_verified only when every clause passes and no blocking model/observation gap; failed: behavior contradicted the oracle; inconclusive: evidence unavailable; unsupported: execution left the model; unproven: the twin lacks parts in diagram.coverage. Firmware: `source` + explicit `board`, `language`, matching `entryPath` (compile-then-run), or precompiled `firmware_ref`+`target`. The REQUIRED `oracle` (>=1 clause) asserts observable evidence: `serial` markers (stop-on-match, so print-then-crash reports the fault), a `display` paint (refresh generation + inked bytes from framebuffer artifacts), `registers`/`gpio` final state. Empty/missing oracle: ORACLE_REQUIRED, never a pass on execution alone; model verification on the twin, not hardware proof. `stimuli` drives a sensor mid-run; the verdict names the vector, and a refused or unreached stimulus never passes. More than one MCU runs as a WORLD: every chip compiled and stepped together with wires modelled, verdict ANDed. That path takes `source` (no precompiled ref), one image per MCU unless `firmware_by_part` overrides, each console in `nodes`; a `serial` clause passes when ANY node satisfies it (named). Serial evidence ONLY there: `display`/`registers`/`gpio` clauses and `stimuli` are rejected up front.

labwired_verify

Run a saved project on the hosted twin and record the proof that publishing needs. With no oracle a marker is inferred, which can only add proof; a declared oracle is a promise and the only thing that refuses a clean run. Signed-in users only, not API keys.

labwired_project_verify

Show the single Circuit / PCB / 3D viewer for PCB workflows: copper, ratsnest, unrouted links, DRC markers and the schematic. Its Circuit tab uses this board's saved circuit, so do not also call labwired_lab for a second widget. Call once when PCB work is complete. Takes {board_id, rev?} (rev defaults to the latest) and returns the board summary with short-lived links to the drawings. Read-only.

labwired_pcb_view