@intentic/sandbox-contract 1.310.0 → 1.311.0

package/README.md

@@ -1,164 +1,43 @@
-# @intentic/sandbox-contract
-
-The wire between the sandbox daemon and its browser client: change it here, and both sides follow.
-
-Every route the daemon serves, every event it pushes, and every shape either side sends is declared once in this
-package as an oRPC contract plus Zod schemas. The daemon implements the contract; the web app consumes it; a
-mismatch is a type error rather than a runtime surprise.
-
-## Responsibilities
-
-- Declare the contracts, one file per subject area (`src/contracts/`).
-- Declare every route's policy beside it ([src/protocol/route-meta.ts](src/protocol/route-meta.ts)): whether the
-  session middleware or the route's own credential check admits a request, the member floor, the guest list, which
-  machine credentials (panel, agent, sync, control rungs) reach it, and whether it answers before boot or streams.
-  Every procedure is built from the one `procedure` builder, so each carries a `RouteMeta` whose absent fields are the
-  defaults. The routes the daemon serves outside oRPC are rows of
-  [src/protocol/raw-routes.ts](src/protocol/raw-routes.ts) with the same meta, and `sandboxRouteFor`
-  ([src/protocol/routes.ts](src/protocol/routes.ts)) resolves a request to the route that serves it, reading the path
-  the way Hono or oRPC's router will. The daemon derives every gate from these and keeps no path table of its own.
-- Declare the wire shapes those contracts are built from, one module per subject area (`src/schemas/`).
-- Declare the event union the daemon pushes over SSE (`src/events.ts`), and the transcript a turn becomes: the
-  rows, the patches that change them and the facts about a turn that `/agent/attach` carries.
-- Hold the small pieces of logic that BOTH sides must agree on rather than each deciding: the chore book,
-  hostname and tunnel-id rules, session naming, terminal protocol, workspace state, runtime state, and the two
-  things every surface that waits on a daemon-run command needs (`src/command-run.ts`): the loop that follows a
-  `CommandRun` to its verdict, and the words over a settled one, so the card in the app and the notification on
-  a phone say the same thing about the same push.
-- Define workflow designs and immutable run snapshots, including full model/account/harness pins, per-step spend
-  ceilings, pinned repository bases, bounded report previews, and complete-report artifact paths.
-- Hold the embeds' half of the public doors (the daemon's `automations/public-door.ts`): `src/embed.ts`, its
-  own entry point and import-free on purpose, is what the Visitor chat widget and the bug reporter both do before
-  they do anything of their own — the door's three calls, the proof-of-work solver, the localStorage id, the
-  script-tag boot.
-- Hold the far end of the peer doors (the daemon's `peers/`): the hello each peer sends (`host-protocol.ts`,
-  `webext-protocol.ts`, `runner-protocol.ts`), the one outbound socket loop every peer runs
-  (`src/peer-dial.ts`, its own entry point) and the MCP tool server a device or a browser answers over it
-  (`src/peer-mcp-server.ts`, its own entry point). Runtime-neutral by construction, since one of those peers is
-  an MV3 service worker.
+# sandbox-contract
+
+The wire contract between the editor and the sandbox daemon: every route, its schemas and its access policy, as one oRPC contract both ends compile against.
+
+```mermaid
+flowchart LR
+    web["Editor<br/>typed oRPC client"] --> contract(["sandboxContract"])
+    ext["Extensions<br/>api.sandbox.rpc"] --> contract
+    contract --> daemon["Sandbox daemon<br/>route factories"]
+    daemon -- "device · webext<br/>runner contracts" --> peers["Machines · browser extension<br/>runners"]
+    contract -. "contract.lock.json" .-> shrink["contract-shrink<br/>push gate"]
+    contract -. "generated from" .-> openapi["sandbox-openapi"]
+```
+
+- Each subject pairs a route group in `src/contracts/*.contract.ts` with its wire shapes in `src/schemas/`.
+  `src/index.ts` assembles them into `sandboxContract`, which the daemon implements per domain and the browser calls
+  through one typed client.
+- Policy sits beside each route: `procedure()` declares how a request authenticates, which member tier it needs and how
+  far a control token reaches. Routes outside oRPC (streams, WebSocket upgrades, `/health`) are listed in
+  `RAW_ROUTES`.
+- Three contracts run the other way. `deviceContract`, `webextContract` and `runnerContract` are served by a user's
+  machine, the browser extension and a runner over the socket each one opens, with the daemon as the client.
+- The daemon names the routes it implements on the `/events` hello frame, and the browser diffs that list against its
+  own build, so a route an older daemon lacks shows as a missing feature instead of a 404.
+- `contract.lock.json` is every exported schema as canonical JSON Schema. `pnpm verify:turn` rewrites it, and
+  `_tools/checks/contract-shrink.mjs` refuses a push that shrinks it unless a commit declares the break (`type!:` or
+  `Breaking-Note:`).
 
 ## Key files
 
-- [src/contracts](src/contracts): one contract per area. Start with `agent.contract.ts` and `git.contract.ts`.
-- [src/schemas](src/schemas): the wire shapes, one module per subject area, named to match the contract that
-  spends them (`schemas/git/git.ts` under `contracts/git.contract.ts`). A contract imports the two or three modules
-  it actually needs, so what a subject area is built from is visible in its import block rather than implied by
-  proximity in a shared file. `schemas/internal.ts` is the exception and is not re-exported from the index: it
-  holds the id and ref primitives several modules are written in, which are vocabulary rather than shapes either
-  side of the wire sends.
-- [src/events/](src/events): what the daemon pushes, and when, one file per family — the cards a turn raises
-  ([cards.ts](src/events/requests.ts)), the transcript wire ([transcript.ts](src/events/transcript.ts): a
-  `TranscriptRow` (a speaker's bubble, a notice, a card), a `TranscriptPatch` (append, replace, drop, more text or
-  thinking, a tool's progress)), the turn's own frames ([agent-events.ts](src/events/agent-events.ts): the
-  `AgentEvent` union, the `TurnFact` view of it, and the `AttachFrame` union a window follows a run through), the
-  resume notes ([resume.ts](src/events/resume.ts)), the two other prompts the daemon composes and sends as turns —
-  a condition watch's wake ([watch-wake.ts](src/events/watch-wake.ts)) and the unverified-work follow-up
-  ([verify-nudge.ts](src/events/verify-nudge.ts)), each recognisable by its opening so the chat can draw it as
-  something other than the user's own words — and what is about the sandbox rather than a turn
-  ([system-events.ts](src/events/system-events.ts): heartbeat, boot, presence, what just moved).
-- [src/transcript-fold.ts](src/text/transcript-fold.ts), its own entry point (`@intentic/sandbox-contract/transcript-fold`):
-  THE fold from a turn's frames to its rows, and the patches each frame is worth. The daemon runs it inside every
-  run, the demo runs it over its recording, and the browser only applies the patches it emits, so there is one
-  opinion about what a turn looks like. Its notices (a stop, a refusal, a landing, a routed tier) are written
-  here too, and so is the one turn that leaves NO rows: a refusal that ran nothing takes its message back out
-  with it and is never recorded, since the composer still holds those words
-  ([docs/design/turns-that-never-ran.md](../../docs/design/turns-that-never-ran.md)). [src/policy/request-status.ts](src/policy/request-status.ts) is how a request settles: raised `pending`, and given its
-  status by the reply that released it or by the stop that cancelled it. One card is settled by a reply the
-  daemon may REFUSE: a `credential_offer` is addressed to the named people the owner's gate lists rather than
-  to whoever holds a session, so a reply that reaches this derivation at all is one the daemon already accepted
-  from an approver, and who that was rides on the `credential_receipt` frame (the reply carries no sender).
-- [src/state/fix-stance.ts](src/state/fix-stance.ts) and [src/state/fix-attempt-plan.ts](src/state/fix-attempt-plan.ts):
-  what became of the agent a surface sent after a failure (working, needs you, fix ready, landed, waiting, ended),
-  and what a press on that surface does about it (open attempt 1, continue the ended attempt, start over, or wait
-  for the one in play). Read here rather than in any one surface, so the editor's push question, the pipelines
-  board and the daemon's `/ci/fix` route describe one agent one way and never race a second one beside it. The
-  attempt ids are [src/ids/conversation-ids.ts](src/ids/conversation-ids.ts): the failure's derived id for
-  attempt 1, then `-attempt2` on, so every attempt keeps its own transcript, cost and URL.
-- [src/workspace-state.ts](src/state/workspace-state.ts) and [src/runtime-state.ts](src/state/runtime-state.ts): which
-  changed file, and which moved runtime thing, makes which browser view stale. The workspace table also assigns
-  each daemon-owned path its export lifecycle (`carry`, `secret`, `identity`, or `derived`), including the
-  auth/session/cache/artifact roots, and marks the configuration slice the root repo TRACKS (`versioned`: the
-  allowlist the git exclude rules are derived from, so a store added later is untracked until someone says
-  otherwise) and the authored-content slice a workspace SEARCH may surface (`versioned` + `authored` →
-  `SEARCHABLE_STATE_PATHS`, which iq's floor denies the rest of `.intentic` against by default). The same flag
-  decides what an isolated turn shares LIVE with the main tree (`SHARED_STATE_PATHS`: every untracked group, bound
-  in over the worktree) and what is the worktree's own checkout that reaches the main tree by landing (the
-  tracked `config/` slice). Extensions name
-  their scratch home through `extensionRuntimeDir` rather than spelling the layout themselves. The daemon
-  publishes the cause and the browser derives the consequence, so neither side keeps its own copy of the
-  other's list.
-- [src/documents.ts](src/text/documents.ts): which of a turn's writes is a DOCUMENT, a markdown file written whole,
-  as opposed to a change made to code. Shared because both sides act on the same answer: the daemon attaches
-  that document to the question or plan card the turn parks on (so a choice can be read beside the write-up it
-  is about), and the browser draws the write's own card as prose rather than as a diff stat. Two copies of the
-  rule would let a card carry a document the transcript never drew.
-- The provider vocabulary, three modules, bottom-up, and the arrow between them only points one way:
-  - [src/agent-runtimes.ts](src/models/agent-runtimes.ts): what each agentic LOOP can do, one record per runtime: its
-    permission axis, its MCP reach, whether it steers, and how much of the owner's system prompt it will take
-    (`instructions`: replace, add, or nothing at all), plus whether it discovers loaded skills natively or
-    needs their catalogue in its opening prompt. It names no providers at all.
-  - [src/provider-specs.ts](src/models/provider-specs.ts): **one row per provider**, and the source every other list
-    of providers in this repo derives from — the wire vocabulary (`NATIVE_PROVIDERS`), the picker's labels, the
-    access and vendor tables, the plan-limit list, the routed-provider enum and its accounts schema, the
-    daemon's CLIProxyAPI id map, and the web's account tabs and readiness rules. A row carries the two axes it
-    deliberately keeps apart: what a turn COSTS (`access`) and what the user CONNECTS (`auth`: an OAuth account
-    this daemon stores, a subscription the bundled translator holds, or a sign-in that MINTS the vendor's own
-    API key, which then carries its estates' base URLs — Z.ai sells one plan through two of them and a key
-    minted on one is refused by the other's host).
-    `brand` is typed against the marks in `@intentic/constants`, so a provider added without a logo does not
-    compile. **Adding a provider is a row here**, its brand path, and (daemon-side) one line in the provider
-    registry; `provider-specs.test.ts` walks the table rather than a list, so the guard covers a provider the
-    day it is added.
-  - [src/contracts/accounts.contract.ts](src/contracts/accounts.contract.ts): the accounts the sandbox holds
-    itself, one route family with the provider as a parameter (`/accounts/{provider}`), the lesson the
-    catalog route learned applied to sign-ins: start, complete, cancel, list, rename, disconnect are the same
-    six verbs for every provider, and `LoginStart` (schemas/providers/provider-oauth.ts) is the one sign-in shape,
-    whose `flow` says how an attempt ENDS (device, redirect, paste). Nothing redeemable is on any answer.
-  - [src/agent-catalog.ts](src/models/agent-catalog.ts): the shapes each surface reads that table in, plus the rules
-    that are about something other than a provider (the trial, the endpoint namespace, the effort and fast-mode
-    gates). Shared because both sides act on it: the daemon composes a turn's instructions and skill discovery
-    against it and the browser both discloses what a pair cannot do (`limitationsOf`) and names which models
-    the system-prompt setting reaches.
-- [src/chores](src/chores), the chore book: definitions, applicability gates and verdicts, shared because the
-  daemon computes the signals and the browser renders the judgement.
-- [src/approvals-execution.ts](src/policy/approvals-execution.ts): how an approved item gets done, the hold every
-  approval starts with, which platforms the daemon posts to by code, and the prompts the executing turns are
-  handed, shared because the daemon acts on them and the Approvals page counts the same seconds down.
-- [src/workflow-faults.ts](src/text/workflow-faults.ts) and [src/output-fields.ts](src/policy/output-fields.ts): graph and
-  structured-output invariants shared by the designer and daemon, including duplicate field-name rejection.
-- [src/definition.ts](src/state/definition.ts): the SANDBOX DEFINITION, the declarable shape of a sandbox
-  (`sandbox.toml`): repositories by remote, connections by shape, secret names, the overlay as source, the
-  non-default agent settings — plus the bundle manifest that embeds it, since a bundle is definition + state.
-  Shared because the daemon derives definitions and the browser renders them and their diffs; the definition
-  never carries a credential value or an approval hash, so it is the export that is safe to publish. Only the
-  OUTBOUND half lives here; applying one is an arrival.
-- [src/arrival.ts](src/state/arrival.ts): the ARRIVAL PIPELINE, one plan → apply → report for every artifact that can
-  come into a sandbox — a definition, an environment bundle, a Hermes or OpenClaw home directory. There were
-  three of these once, one per artifact, and the differences between them were drift rather than design (only
-  two of the three previewed; the credential consent was asked on opposite sides). The artifact is a parser
-  now and everything after it is shared, which is what lets one card render all four.
-- [src/index.ts](src/index.ts): the public surface.
-- [src/contract-lock.ts](src/state/contract-lock.ts) and [contract.lock.json](contract.lock.json): every exported
-  schema serialized to one committed, comparable document. Regenerate with `pnpm --filter
-  @intentic/sandbox-contract lock` whenever a schema changes; the test beside it fails until you do, and the
-  repo-level `contract-shrink` check refuses a push whose lock *lost or changed* an existing surface without a declared
-  breaking change (COMPATIBILITY.md at the repo root has the whole story).
-
-## How it fits
-
-Depended on by `_sandbox/sandbox` (the daemon) and `_editor/web` (the browser), by `@intentic/extension-api` (so
-`api.sandbox.rpc` can be typed), and by every extension that talks to any of them. Its few shared dependencies
-include `@intentic/extension-manifest`, for the install shape, and `@intentic/registry`, for marketplace rows and
-their source-bound admission evidence. Keeping those schemas outside `extension-api` lets every plane import
-the wire without a cycle.
+- [src/index.ts](src/index.ts) — `sandboxContract`, the route tables derived from it, and every public export.
+- [src/protocol/route-meta.ts](src/protocol/route-meta.ts) — the per-route policy fields and their defaults.
+- [src/protocol/raw-routes.ts](src/protocol/raw-routes.ts) — every route the daemon serves outside oRPC.
+- [src/protocol/routes.ts](src/protocol/routes.ts) — route naming, `streamOf` for streamed routes, and the route list a daemon advertises.
+- [contract.lock.json](contract.lock.json) — the committed fingerprint of the wire surface.
+- [src/webext/index.ts](src/webext/index.ts) — a narrow entry point, one of several that keep small bundles off the barrel.
 
-## Conventions & gotchas
+## Commands
 
-- **A route's policy is its meta.** A new procedure uses its file's builder (`secretRoute`, `systemRoute`, …, or
-  `procedure`) and declares only what differs from the defaults; a raw route is a `RAW_ROUTES` row before the daemon can
-  register it at all. The daemon's `auth/route-reach.test.ts` records every route's decisions, so a new route fails it
-  until its row is written, and a changed row is a route that became more or less reachable.
-- **Logic lives here only when both sides must agree on it.** A chore's verdict qualifies; a view's layout does
-  not. When in doubt, the test is whether disagreement between daemon and browser would be a bug.
-- A cross-package type change may not resolve until the workspace settles: `@intentic/*` imports go through
-  `node_modules` to the main checkout's source. See the workspace README before concluding an export is missing.
+```sh
+pnpm --filter @intentic/sandbox-contract lock   # rebuild, then rewrite contract.lock.json
+pnpm --filter @intentic/sandbox-contract test
+```

package/dist/contracts/accounts.contract.d.ts

@@ -49,6 +49,7 @@ export declare const accountsContract: {
             connectedAt: import("zod").ZodNumber;
             needsReauth: import("zod").ZodOptional<import("zod").ZodBoolean>;
             detail: import("zod").ZodOptional<import("zod").ZodString>;
+            seatRefusal: import("zod").ZodOptional<import("zod").ZodString>;
             usage: import("zod").ZodOptional<import("zod").ZodObject<{
                 windows: import("zod").ZodArray<import("zod").ZodObject<{
                     kind: import("zod").ZodString;
@@ -100,6 +101,7 @@ export declare const accountsContract: {
             connectedAt: import("zod").ZodNumber;
             needsReauth: import("zod").ZodOptional<import("zod").ZodBoolean>;
             detail: import("zod").ZodOptional<import("zod").ZodString>;
+            seatRefusal: import("zod").ZodOptional<import("zod").ZodString>;
             usage: import("zod").ZodOptional<import("zod").ZodObject<{
                 windows: import("zod").ZodArray<import("zod").ZodObject<{
                     kind: import("zod").ZodString;
@@ -136,6 +138,7 @@ export declare const accountsContract: {
         connectedAt: import("zod").ZodNumber;
         needsReauth: import("zod").ZodOptional<import("zod").ZodBoolean>;
         detail: import("zod").ZodOptional<import("zod").ZodString>;
+        seatRefusal: import("zod").ZodOptional<import("zod").ZodString>;
         usage: import("zod").ZodOptional<import("zod").ZodObject<{
             windows: import("zod").ZodArray<import("zod").ZodObject<{
                 kind: import("zod").ZodString;

package/dist/contracts/accounts.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"accounts.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/accounts.contract.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,gBAAgB;IACzB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;IAUL,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUR,MAAM;;;;;;;;;;;;;;;IAUN,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUR,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IASN,UAAU;;;;;;;;;;;;;;;CASb,CAAC"}
+{"version":3,"file":"accounts.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/accounts.contract.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,gBAAgB;IACzB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;IAUL,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUR,MAAM;;;;;;;;;;;;;;;IAUN,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUR,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IASN,UAAU;;;;;;;;;;;;;;;CASb,CAAC"}

package/dist/contracts/agent.contract.d.ts

@@ -628,6 +628,11 @@ export declare const agentContract: {
             op: "thinking";
             index: number;
             text: string;
+        } | {
+            op: "toolThinking";
+            index: number;
+            id: string;
+            text: string;
         } | {
             op: "tool";
             index: number;
@@ -1180,6 +1185,11 @@ export declare const agentContract: {
             op: "thinking";
             index: number;
             text: string;
+        } | {
+            op: "toolThinking";
+            index: number;
+            id: string;
+            text: string;
         } | {
             op: "tool";
             index: number;
@@ -2006,6 +2016,11 @@ export declare const agentContract: {
                 op: import("zod").ZodLiteral<"thinking">;
                 index: import("zod").ZodNumber;
                 text: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                op: import("zod").ZodLiteral<"toolThinking">;
+                index: import("zod").ZodNumber;
+                id: import("zod").ZodString;
+                text: import("zod").ZodString;
             }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
                 op: import("zod").ZodLiteral<"tool">;
                 index: import("zod").ZodNumber;

package/dist/contracts/agent.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/agent.contract.ts"],"names":[],"mappings":"AAuBA,eAAO,MAAM,aAAa;IACtB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAYH,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAYN,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWL,KAAK;;;;;;;;;;;;;;;;;;;;;IAWL,IAAI;;;;;;;;;;;;;IAYJ,SAAS;;;;;;;;;;;;;;;;;;;;;;;;IAYT,WAAW;;;;;;;;;;;;;;;;;;;;;;;IAWX,WAAW;;;;;;;;;;;;;;;IAYX,MAAM;;;;;;;;;;;;;;;IAcN,MAAM;;;;;;;;IAWN,QAAQ;;;;;;;;;IAaR,SAAS;;;;;;;;;;;;;;;;;;;;;;;;IAYT,QAAQ;;;;;;;;;;;;;CAUX,CAAC"}
+{"version":3,"file":"agent.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/agent.contract.ts"],"names":[],"mappings":"AAuBA,eAAO,MAAM,aAAa;IACtB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAYH,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAYN,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWL,KAAK;;;;;;;;;;;;;;;;;;;;;IAWL,IAAI;;;;;;;;;;;;;IAYJ,SAAS;;;;;;;;;;;;;;;;;;;;;;;;IAYT,WAAW;;;;;;;;;;;;;;;;;;;;;;;IAWX,WAAW;;;;;;;;;;;;;;;IAYX,MAAM;;;;;;;;;;;;;;;IAcN,MAAM;;;;;;;;IAWN,QAAQ;;;;;;;;;IAaR,SAAS;;;;;;;;;;;;;;;;;;;;;;;;IAYT,QAAQ;;;;;;;;;;;;;CAUX,CAAC"}