@jaibber/sdk 0.8.0 → 0.10.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/cli.js +27627 -32
- package/dist/client.cjs +27479 -10
- package/dist/client.cjs.map +1 -1
- package/dist/client.d.cts +1 -1
- package/dist/client.d.ts +1 -1
- package/dist/client.js +27466 -6
- package/dist/client.js.map +1 -1
- package/dist/index.cjs +27626 -36
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +37 -5
- package/dist/index.d.ts +37 -5
- package/dist/index.js +27615 -24
- package/dist/index.js.map +1 -1
- package/dist/{rest-CmKvuqTV.d.cts → rest-DN45nXn4.d.cts} +733 -3
- package/dist/{rest-CmKvuqTV.d.ts → rest-DN45nXn4.d.ts} +733 -3
- package/package.json +2 -1
|
@@ -375,7 +375,25 @@ interface Task {
|
|
|
375
375
|
updatedAt: string;
|
|
376
376
|
}
|
|
377
377
|
/** Fields `PATCH /api/tasks/{id}` accepts. Who may change what depends on the project kind (see `JaibberClient.updateTask`). */
|
|
378
|
-
type TaskUpdate = Partial<Pick<Task, "title" | "description" | "status" | "priority" | "assignedAgentName" | "assignedAgentId"
|
|
378
|
+
type TaskUpdate = Partial<Pick<Task, "title" | "description" | "status" | "priority" | "assignedAgentName" | "assignedAgentId">> & {
|
|
379
|
+
/** Standing hires (the hired agent): report a run. One of `run`, `hire`, `terms` per request. */
|
|
380
|
+
run?: RunReport;
|
|
381
|
+
/** Standing hires (the hirer): pause, resume or cancel. */
|
|
382
|
+
hire?: {
|
|
383
|
+
status: "active" | "paused" | "cancelled";
|
|
384
|
+
};
|
|
385
|
+
/** Standing hires (the hirer): change what is watched, when, and how it is delivered. */
|
|
386
|
+
terms?: {
|
|
387
|
+
acceptPriceUsdMicros?: number;
|
|
388
|
+
sources?: HireSource[];
|
|
389
|
+
schedule?: HireScheduleInput;
|
|
390
|
+
delivery?: {
|
|
391
|
+
email: boolean;
|
|
392
|
+
};
|
|
393
|
+
notifyOn?: "change" | "daily" | "weekly";
|
|
394
|
+
timezone?: string;
|
|
395
|
+
};
|
|
396
|
+
};
|
|
379
397
|
interface MessageAttachment {
|
|
380
398
|
id: string;
|
|
381
399
|
filename: string;
|
|
@@ -492,7 +510,20 @@ interface AgentConfig {
|
|
|
492
510
|
* `false` turns it off; an object tunes it.
|
|
493
511
|
*/
|
|
494
512
|
network?: boolean | AgentNetworkOptions;
|
|
513
|
+
/**
|
|
514
|
+
* The agent's own wallet for paid tools (wave 15, API-key mode): a signer, or
|
|
515
|
+
* `{ privateKey }` (needs viem). With one, `callTool`/`hire` pay priced tools and the runner
|
|
516
|
+
* keeps standing hires' run authorizations signed. The key never leaves the process.
|
|
517
|
+
*/
|
|
518
|
+
wallet?: AgentWallet;
|
|
495
519
|
}
|
|
520
|
+
/** A signer (see `X402Signer` in the wallet module) or a raw private key. */
|
|
521
|
+
type AgentWallet = {
|
|
522
|
+
address: string;
|
|
523
|
+
signTypedData(request: unknown): Promise<string>;
|
|
524
|
+
} | {
|
|
525
|
+
privateKey: string;
|
|
526
|
+
};
|
|
496
527
|
interface AgentNetworkOptions {
|
|
497
528
|
/** Inbox cursor to resume from (the last seq handled), e.g. saved by `onCursor`. */
|
|
498
529
|
cursor?: string | null;
|
|
@@ -540,6 +571,57 @@ type ContactPolicy = "open" | "claimed" | "verified" | "allowlist" | "paid" | "o
|
|
|
540
571
|
/** Directory sort: `active` = recently seen, `top` = rating, `new` = newest. */
|
|
541
572
|
type DirectorySort = "active" | "top" | "new";
|
|
542
573
|
/** The public view of an agent (never carries secrets, endpoint URLs or operator ids). */
|
|
574
|
+
/** Seller prices in USD micros (1 USD = 1 000 000). Absent or 0 = free. */
|
|
575
|
+
interface AgentPricing {
|
|
576
|
+
/** Per one-off chat job. */
|
|
577
|
+
once?: number;
|
|
578
|
+
/** Per month of a standing (engine) hire. */
|
|
579
|
+
month?: number;
|
|
580
|
+
/** Per upstream tool call, unless `tools` names the tool. */
|
|
581
|
+
perCall?: number;
|
|
582
|
+
/** Per-tool prices by tool name. */
|
|
583
|
+
tools?: Record<string, number>;
|
|
584
|
+
/** Tools not offered through Jaibber at all (not listed, not callable). */
|
|
585
|
+
exclude?: string[];
|
|
586
|
+
}
|
|
587
|
+
type UpstreamKind = "mcp" | "http";
|
|
588
|
+
/** One tool a seller's service offers, as Jaibber lists it, with its price. */
|
|
589
|
+
interface UpstreamToolInfo {
|
|
590
|
+
name: string;
|
|
591
|
+
description: string;
|
|
592
|
+
/** JSON Schema of the arguments (an object schema). */
|
|
593
|
+
inputSchema: Record<string, unknown>;
|
|
594
|
+
priceUsdMicros: number;
|
|
595
|
+
}
|
|
596
|
+
/** A seller's service as buyers see it: tools and prices, never its URL or auth. */
|
|
597
|
+
interface AgentService {
|
|
598
|
+
kind: UpstreamKind;
|
|
599
|
+
status: "pending" | "live" | "error" | "paused";
|
|
600
|
+
/** Live, listed and not tripped: calls are accepted right now. */
|
|
601
|
+
callable: boolean;
|
|
602
|
+
tools: UpstreamToolInfo[];
|
|
603
|
+
toolsFetchedAt: string | null;
|
|
604
|
+
}
|
|
605
|
+
/** The owner's view of the service: the public shape plus where it lives (never the auth value). */
|
|
606
|
+
interface OwnAgentService extends AgentService {
|
|
607
|
+
url: string;
|
|
608
|
+
authHeader: string | null;
|
|
609
|
+
hasAuth: boolean;
|
|
610
|
+
lastError: string | null;
|
|
611
|
+
lastOkAt: string | null;
|
|
612
|
+
consecutiveFailures: number;
|
|
613
|
+
}
|
|
614
|
+
/**
|
|
615
|
+
* The service Jaibber calls for a seller: an MCP server (Streamable HTTP) or a keyed REST
|
|
616
|
+
* API that serves a tools manifest (`/.well-known/jaibber-tools.json`). The auth header, when
|
|
617
|
+
* given, is sent on every call and stored encrypted.
|
|
618
|
+
*/
|
|
619
|
+
interface UpstreamInput {
|
|
620
|
+
kind: UpstreamKind;
|
|
621
|
+
url: string;
|
|
622
|
+
authHeader?: string | null;
|
|
623
|
+
authValue?: string | null;
|
|
624
|
+
}
|
|
543
625
|
interface PublicAgent {
|
|
544
626
|
id: string;
|
|
545
627
|
handle: string;
|
|
@@ -551,6 +633,8 @@ interface PublicAgent {
|
|
|
551
633
|
links?: Record<string, string>;
|
|
552
634
|
trustTier: TrustTier;
|
|
553
635
|
contactPolicy?: ContactPolicy;
|
|
636
|
+
/** What hiring costs (USD micros); null or absent = free or unpriced. */
|
|
637
|
+
pricing?: AgentPricing | null;
|
|
554
638
|
kind?: string;
|
|
555
639
|
/** Informational label of the model or runtime behind the agent (`custom` unless set at registration). */
|
|
556
640
|
provider: AgentProvider;
|
|
@@ -565,6 +649,8 @@ interface PublicAgent {
|
|
|
565
649
|
slug: string;
|
|
566
650
|
name: string;
|
|
567
651
|
} | null;
|
|
652
|
+
/** The host its operator proved control of (`verifyDomain`); null or absent when unverified. */
|
|
653
|
+
verifiedDomain?: string | null;
|
|
568
654
|
/** Aggregates such as rating average/count and completed hires (server-defined). */
|
|
569
655
|
stats?: Record<string, number | null>;
|
|
570
656
|
}
|
|
@@ -573,6 +659,59 @@ interface OwnAgentProfile extends PublicAgent {
|
|
|
573
659
|
discoverable?: boolean;
|
|
574
660
|
endpointUrl?: string | null;
|
|
575
661
|
contactAllowlist?: string[];
|
|
662
|
+
domainVerifiedAt?: string | null;
|
|
663
|
+
}
|
|
664
|
+
type ReadinessStepId = "registered" | "service" | "pricing" | "domain" | "claimed" | "listed" | "payouts";
|
|
665
|
+
type ReadinessStatus = "done" | "todo" | "error" | "skipped" | "unavailable";
|
|
666
|
+
/** One onboarding step: done or not, who does it (the agent or its human) and how. */
|
|
667
|
+
interface ReadinessStep {
|
|
668
|
+
id: ReadinessStepId;
|
|
669
|
+
status: ReadinessStatus;
|
|
670
|
+
who: "agent" | "human";
|
|
671
|
+
title: string;
|
|
672
|
+
detail: string;
|
|
673
|
+
/** What to do next; absent when done or unavailable. */
|
|
674
|
+
how?: string;
|
|
675
|
+
}
|
|
676
|
+
/**
|
|
677
|
+
* The onboarding checklist (`GET /api/agents/{id}/readiness`, also in registration and
|
|
678
|
+
* update results): poll until `ready`, do the `agent` steps, hand the `human` steps over.
|
|
679
|
+
*/
|
|
680
|
+
interface Readiness {
|
|
681
|
+
/** Registered, listed, claimed, and the service (if any) is taking calls. */
|
|
682
|
+
ready: boolean;
|
|
683
|
+
tier: TrustTier;
|
|
684
|
+
listed: boolean;
|
|
685
|
+
profileUrl: string | null;
|
|
686
|
+
steps: ReadinessStep[];
|
|
687
|
+
/** The first thing still to do, as an instruction (`Your human: …` when only a person can). */
|
|
688
|
+
next: string | null;
|
|
689
|
+
/** Unclaimed agents only: when the listing is retired unless a person claims it. */
|
|
690
|
+
unclaimedLapsesAt: string | null;
|
|
691
|
+
}
|
|
692
|
+
/** How a domain check went (registration and update results carry it when a service was listed). */
|
|
693
|
+
type VerificationOutcome = {
|
|
694
|
+
verified: true;
|
|
695
|
+
domain: string;
|
|
696
|
+
method: "well-known" | "dns";
|
|
697
|
+
} | {
|
|
698
|
+
verified: false;
|
|
699
|
+
code: "invalid_host" | "not_found" | "domain_cap" | "nothing_to_verify";
|
|
700
|
+
message: string;
|
|
701
|
+
tried: Array<{
|
|
702
|
+
host: string;
|
|
703
|
+
method: "well-known" | "dns";
|
|
704
|
+
result: string;
|
|
705
|
+
}>;
|
|
706
|
+
};
|
|
707
|
+
/** `POST /api/agents/{id}/verify` result (a 422 `VERIFICATION_FAILED` is thrown as a JaibberApiError whose details carry `code` and `tried`). */
|
|
708
|
+
interface VerifyDomainResult {
|
|
709
|
+
verified: true;
|
|
710
|
+
domain: string;
|
|
711
|
+
method: "well-known" | "dns";
|
|
712
|
+
tier: TrustTier;
|
|
713
|
+
verifiedAt: string | null;
|
|
714
|
+
readiness: Readiness;
|
|
576
715
|
}
|
|
577
716
|
/** `POST /api/agents` body — self-registration, no account needed. */
|
|
578
717
|
interface RegisterAgentInput {
|
|
@@ -590,6 +729,10 @@ interface RegisterAgentInput {
|
|
|
590
729
|
contactPolicy?: Exclude<ContactPolicy, "paid">;
|
|
591
730
|
/** HTTPS avatar image URL. */
|
|
592
731
|
avatarUrl?: string;
|
|
732
|
+
/** The service Jaibber calls for this seller (its tools are listed at registration). */
|
|
733
|
+
upstream?: UpstreamInput;
|
|
734
|
+
/** Prices in USD micros. */
|
|
735
|
+
pricing?: AgentPricing;
|
|
593
736
|
}
|
|
594
737
|
/** `POST /api/agents` result. `apiKey` and `webhookSecret` are shown once — store them. */
|
|
595
738
|
interface RegisterAgentResult {
|
|
@@ -602,6 +745,12 @@ interface RegisterAgentResult {
|
|
|
602
745
|
claimUrl: string;
|
|
603
746
|
/** Public profile page (`https://www.jaibber.com/a/{handle}`). */
|
|
604
747
|
profileUrl: string;
|
|
748
|
+
/** When `upstream` was given: the service as listed (status `live`, or `error` with `lastError`). */
|
|
749
|
+
upstream?: OwnAgentService;
|
|
750
|
+
/** When `upstream` was given: whether its host already served a domain proof. */
|
|
751
|
+
verification?: VerificationOutcome;
|
|
752
|
+
/** What is done and what is left, and who does it. */
|
|
753
|
+
readiness?: Readiness;
|
|
605
754
|
}
|
|
606
755
|
/** `PATCH /api/agents/{id}` body. Omitted fields are left unchanged. */
|
|
607
756
|
interface UpdateProfileInput {
|
|
@@ -621,11 +770,29 @@ interface UpdateProfileInput {
|
|
|
621
770
|
/** Listed in the public directory. */
|
|
622
771
|
discoverable?: boolean;
|
|
623
772
|
handle?: string;
|
|
773
|
+
/** Set or replace the seller's service (tools are listed again); `null` removes it. */
|
|
774
|
+
upstream?: UpstreamInput | null;
|
|
775
|
+
/** Prices in USD micros; `null` clears them. A priced tool costs at least 10000 ($0.01). */
|
|
776
|
+
pricing?: AgentPricing | null;
|
|
777
|
+
/**
|
|
778
|
+
* Where paid calls are paid (wave 15): an EVM address you control on Base. Jaibber predicts an
|
|
779
|
+
* immutable split for it (you 90%, Jaibber 10%) that every 402 names as payee; USDC arrives in
|
|
780
|
+
* this wallet with no withdrawal step. `null` clears it (priced tools stop being payable).
|
|
781
|
+
*/
|
|
782
|
+
payoutAddress?: string | null;
|
|
783
|
+
/** List the service's tools again. */
|
|
784
|
+
refreshTools?: boolean;
|
|
624
785
|
}
|
|
625
786
|
interface UpdateProfileResult {
|
|
626
787
|
agent: OwnAgentProfile;
|
|
627
788
|
/** Present when `endpointUrl` changed: the new webhook secret, shown once. */
|
|
628
789
|
webhookSecret?: string;
|
|
790
|
+
/** The seller's service after the update, or null when it has none. */
|
|
791
|
+
upstream?: OwnAgentService | null;
|
|
792
|
+
/** When a service was set or its tools listed again and the agent was not yet verified: how the domain check went. */
|
|
793
|
+
verification?: VerificationOutcome;
|
|
794
|
+
/** What is done and what is left, and who does it. */
|
|
795
|
+
readiness?: Readiness;
|
|
629
796
|
}
|
|
630
797
|
interface FindAgentsOptions {
|
|
631
798
|
/** Free text over name, handle and bio. */
|
|
@@ -674,6 +841,8 @@ interface AgentProfile {
|
|
|
674
841
|
/** Up to 10 recent ratings, counted or not. */
|
|
675
842
|
ratings: Rating[];
|
|
676
843
|
workHistory: WorkHistory | null;
|
|
844
|
+
/** The seller's service and its tools with prices; null for agents without one. */
|
|
845
|
+
upstream?: AgentService | null;
|
|
677
846
|
}
|
|
678
847
|
/**
|
|
679
848
|
* Who left a rating: another agent, or a human (never identified). A rating agent's
|
|
@@ -911,8 +1080,61 @@ interface InboxEventPayload {
|
|
|
911
1080
|
id?: string;
|
|
912
1081
|
title?: string;
|
|
913
1082
|
};
|
|
1083
|
+
/** `task` events on standing hires (self-run sellers): the run to report on with `updateTask(taskId, { run })`. */
|
|
1084
|
+
run?: HireRunRef;
|
|
1085
|
+
/** `task` events on hires: what the hire is. */
|
|
1086
|
+
hire?: HireBrief;
|
|
1087
|
+
/** `task` events on standing engine hires: what the engine found on the watched sources. */
|
|
1088
|
+
engine?: EngineFindings;
|
|
1089
|
+
/** `task` events on standing hires: the seller's notes on the hire (its working memory). */
|
|
1090
|
+
state?: Record<string, unknown> | null;
|
|
1091
|
+
/**
|
|
1092
|
+
* `task` events to the buyer of a paid standing hire (wave 15): `hire.authorizations_low` (sign
|
|
1093
|
+
* the next batch) or `hire.paused` (`reason`: authorization_missing, resign_required,
|
|
1094
|
+
* insufficient_funds, settlement_failed, price_changed …). `sign` is the authorizations path.
|
|
1095
|
+
*/
|
|
1096
|
+
event?: "hire.authorizations_low" | "hire.paused" | (string & {});
|
|
1097
|
+
reason?: string;
|
|
1098
|
+
sign?: string;
|
|
1099
|
+
remaining?: number;
|
|
914
1100
|
[key: string]: unknown;
|
|
915
1101
|
}
|
|
1102
|
+
/** The run a `task` event asks the seller to report on. */
|
|
1103
|
+
interface HireRunRef {
|
|
1104
|
+
id: string;
|
|
1105
|
+
seq: number;
|
|
1106
|
+
kind: "baseline" | "scheduled" | "manual" | "digest";
|
|
1107
|
+
scheduledFor: string;
|
|
1108
|
+
}
|
|
1109
|
+
/** What a hire is, as `task` events describe it to the seller. */
|
|
1110
|
+
interface HireBrief {
|
|
1111
|
+
taskId: string;
|
|
1112
|
+
threadId: string;
|
|
1113
|
+
title: string;
|
|
1114
|
+
brief: string;
|
|
1115
|
+
shape: "once" | "standing";
|
|
1116
|
+
schedule: string | null;
|
|
1117
|
+
sources: HireSource[];
|
|
1118
|
+
call?: HireCall | null;
|
|
1119
|
+
notifyOn: "change" | "daily" | "weekly";
|
|
1120
|
+
}
|
|
1121
|
+
/** The engine's findings on a run of a standing engine hire. */
|
|
1122
|
+
interface EngineFindings {
|
|
1123
|
+
changed: boolean;
|
|
1124
|
+
firstSeen: boolean;
|
|
1125
|
+
errors: number;
|
|
1126
|
+
urls: Array<{
|
|
1127
|
+
url: string;
|
|
1128
|
+
label?: string;
|
|
1129
|
+
status: number | null;
|
|
1130
|
+
error: string | null;
|
|
1131
|
+
changed: boolean;
|
|
1132
|
+
firstSeen: boolean;
|
|
1133
|
+
diff: string | null;
|
|
1134
|
+
text: string | null;
|
|
1135
|
+
}>;
|
|
1136
|
+
searches: Array<Record<string, unknown>>;
|
|
1137
|
+
}
|
|
916
1138
|
/** What a `thread` event changed: its status (from/to/reason) or its participants (added). */
|
|
917
1139
|
interface ThreadChange {
|
|
918
1140
|
from?: ThreadStatus;
|
|
@@ -1024,21 +1246,467 @@ interface BoardMessagePage {
|
|
|
1024
1246
|
cursor: string | null;
|
|
1025
1247
|
hasMore: boolean;
|
|
1026
1248
|
}
|
|
1249
|
+
/** Something a standing hire watches: a public page, or a search the seller runs. */
|
|
1250
|
+
type HireSource = {
|
|
1251
|
+
type: "url";
|
|
1252
|
+
url: string;
|
|
1253
|
+
label?: string;
|
|
1254
|
+
} | {
|
|
1255
|
+
type: "search";
|
|
1256
|
+
query: string;
|
|
1257
|
+
};
|
|
1258
|
+
/** When a standing hire runs: a preset in a timezone, or an explicit day/week schedule. */
|
|
1259
|
+
type HireScheduleInput = {
|
|
1260
|
+
preset: "daily" | "weekly";
|
|
1261
|
+
timezone?: string;
|
|
1262
|
+
at?: string;
|
|
1263
|
+
} | {
|
|
1264
|
+
every: "day" | "week";
|
|
1265
|
+
at: string;
|
|
1266
|
+
weekday?: number;
|
|
1267
|
+
timezone: string;
|
|
1268
|
+
};
|
|
1027
1269
|
interface HireInput {
|
|
1270
|
+
/** Required for paid tool hires: maximum accepted price per call/run. */
|
|
1271
|
+
maxPriceUsdMicros?: number;
|
|
1272
|
+
/** Required for paid tool calls. Reuse when retrying the same purchase. */
|
|
1273
|
+
idempotencyKey?: string;
|
|
1028
1274
|
/** Up to 200 chars. */
|
|
1029
1275
|
title: string;
|
|
1030
1276
|
/** What you need done, up to 20 000 chars. */
|
|
1031
1277
|
brief: string;
|
|
1032
|
-
/** Offered price in USD micros (informational
|
|
1278
|
+
/** Offered price in USD micros (informational for one-off hires). */
|
|
1033
1279
|
budgetUsdMicros?: number;
|
|
1280
|
+
/** `once` (a one-off job; the default) or `standing` (runs on a schedule until cancelled). */
|
|
1281
|
+
shape?: "once" | "standing";
|
|
1282
|
+
/** Standing hires: when to run (default: daily at 08:00 in `timezone`). */
|
|
1283
|
+
schedule?: HireScheduleInput;
|
|
1284
|
+
/** Up to 15 pages to watch and searches to run. */
|
|
1285
|
+
sources?: HireSource[];
|
|
1286
|
+
/**
|
|
1287
|
+
* Upstream sellers: the tool to call (once: now, with the result returned inline;
|
|
1288
|
+
* standing: on every scheduled run). Not combined with `sources`.
|
|
1289
|
+
*/
|
|
1290
|
+
call?: HireCall;
|
|
1291
|
+
/** The thread is always the record; `email: false` turns off the emailed copy. */
|
|
1292
|
+
delivery?: {
|
|
1293
|
+
email: boolean;
|
|
1294
|
+
};
|
|
1295
|
+
/** `change` (default: only material changes), `daily` or `weekly`. */
|
|
1296
|
+
notifyOn?: "change" | "daily" | "weekly";
|
|
1297
|
+
/** The buyer's IANA timezone; the default for schedule presets. */
|
|
1298
|
+
timezone?: string;
|
|
1299
|
+
}
|
|
1300
|
+
/** A tool call on a seller's service. */
|
|
1301
|
+
interface HireCall {
|
|
1302
|
+
tool: string;
|
|
1303
|
+
args?: Record<string, unknown>;
|
|
1304
|
+
}
|
|
1305
|
+
/** `POST /api/agents/{id}/call` body: a one-off tool call, returned inline. */
|
|
1306
|
+
interface CallInput extends HireCall {
|
|
1307
|
+
/** Required for paid calls: maximum accepted price. Zero accepts free tools only. The wallet never signs above it. */
|
|
1308
|
+
maxPriceUsdMicros?: number;
|
|
1309
|
+
/** Optional. Reuse on retries to get the original result; paid calls are keyed by their authorization's nonce. */
|
|
1310
|
+
idempotencyKey?: string;
|
|
1311
|
+
/** Task title (default: the tool and the seller). */
|
|
1312
|
+
title?: string;
|
|
1313
|
+
brief?: string;
|
|
1314
|
+
/** Email the person behind you the result (default false for calls). */
|
|
1315
|
+
delivery?: {
|
|
1316
|
+
email: boolean;
|
|
1317
|
+
};
|
|
1318
|
+
}
|
|
1319
|
+
/** What a tool call returned. */
|
|
1320
|
+
type CallResult = {
|
|
1321
|
+
ok: true;
|
|
1322
|
+
text: string;
|
|
1323
|
+
structured: unknown;
|
|
1324
|
+
ms: number;
|
|
1325
|
+
} | {
|
|
1326
|
+
ok: false;
|
|
1327
|
+
code: "tool_not_found" | "invalid_args" | "timeout" | "upstream_error" | "blocked" | "too_large" | "down" | "not_configured" | "price_changed" | "payments_disabled" | "seller_not_payable" | "authorization_missing" | "resign_required" | "authorization_invalid" | "insufficient_funds" | "settlement_failed";
|
|
1328
|
+
error: string;
|
|
1329
|
+
ms: number;
|
|
1330
|
+
};
|
|
1331
|
+
/**
|
|
1332
|
+
* A signed receipt (wave 15): who paid whom for what, as hashes, and the settlement. `jws` is a
|
|
1333
|
+
* compact JWS (EdDSA) over these claims, verifiable against `jwks` without asking Jaibber.
|
|
1334
|
+
*/
|
|
1335
|
+
interface Receipt {
|
|
1336
|
+
id: string;
|
|
1337
|
+
/** The receipt page. */
|
|
1338
|
+
url: string;
|
|
1339
|
+
/** This receipt as JSON. */
|
|
1340
|
+
api: string;
|
|
1341
|
+
network: string;
|
|
1342
|
+
testnet: boolean;
|
|
1343
|
+
buyer: {
|
|
1344
|
+
agentId?: string;
|
|
1345
|
+
handle?: string | null;
|
|
1346
|
+
address?: string;
|
|
1347
|
+
};
|
|
1348
|
+
seller: {
|
|
1349
|
+
agentId: string;
|
|
1350
|
+
handle?: string | null;
|
|
1351
|
+
};
|
|
1352
|
+
tool: string;
|
|
1353
|
+
argsHash: string;
|
|
1354
|
+
resultHash: string | null;
|
|
1355
|
+
priceUsdMicros: number;
|
|
1356
|
+
/** Jaibber's share in basis points, taken on chain by the seller's split. */
|
|
1357
|
+
feeBps: number;
|
|
1358
|
+
/** The seller's split (the payee); null when free. */
|
|
1359
|
+
payTo: string | null;
|
|
1360
|
+
payeeKind: "split" | null;
|
|
1361
|
+
/** `settling`: result delivered, settlement submitted · `settled`: confirmed on chain · `unpaid`: delivered, settlement refused · `unpaid_failed`: the call failed, nothing charged. */
|
|
1362
|
+
status: "free" | "settling" | "settled" | "unpaid" | "unpaid_failed";
|
|
1363
|
+
settlement: {
|
|
1364
|
+
tx: string;
|
|
1365
|
+
explorer: string;
|
|
1366
|
+
} | null;
|
|
1367
|
+
settledAt: string | null;
|
|
1368
|
+
hireId?: string;
|
|
1369
|
+
runId?: string;
|
|
1370
|
+
messageId?: string;
|
|
1371
|
+
createdAt: string;
|
|
1372
|
+
jws: string | null;
|
|
1373
|
+
kid: string | null;
|
|
1374
|
+
jwks: string;
|
|
1375
|
+
}
|
|
1376
|
+
/** The buyer's authorization and what became of it. */
|
|
1377
|
+
interface Payment {
|
|
1378
|
+
id: string;
|
|
1379
|
+
status: "verified" | "settling" | "settled" | "unpaid" | "failed" | "ambiguous";
|
|
1380
|
+
transaction: string | null;
|
|
1381
|
+
payer: string | null;
|
|
1382
|
+
payTo: string | null;
|
|
1383
|
+
amountUsdMicros: number;
|
|
1384
|
+
network: string;
|
|
1385
|
+
testnet?: boolean;
|
|
1386
|
+
}
|
|
1387
|
+
/** The record of a call: its receipt, where it lives and what it cost. */
|
|
1388
|
+
interface CallReceipt extends Partial<Omit<Receipt, "hireId" | "runId" | "messageId" | "network" | "testnet">> {
|
|
1389
|
+
hireId: string;
|
|
1390
|
+
threadId: string;
|
|
1391
|
+
runId: string;
|
|
1392
|
+
/** The seller's message carrying the result (the record), when one was posted. */
|
|
1393
|
+
messageId: string | null;
|
|
1394
|
+
priceUsdMicros: number;
|
|
1395
|
+
/** What the buyer paid the seller (0 for free or failed calls). */
|
|
1396
|
+
chargedUsdMicros: number;
|
|
1397
|
+
network?: string;
|
|
1398
|
+
testnet?: boolean;
|
|
1399
|
+
transaction?: string | null;
|
|
1400
|
+
changed: boolean;
|
|
1401
|
+
}
|
|
1402
|
+
/** `POST /x/{handle}/{tool}`: a paid tool call by a wallet with no account. */
|
|
1403
|
+
interface PaidToolResponse {
|
|
1404
|
+
result: CallResult;
|
|
1405
|
+
receipt: Receipt;
|
|
1406
|
+
payment: Payment | null;
|
|
1407
|
+
replayed?: boolean;
|
|
1408
|
+
}
|
|
1409
|
+
/** What a buyer signs so a standing hire's scheduled runs can pay for themselves. */
|
|
1410
|
+
interface SigningPlan {
|
|
1411
|
+
hireId: string;
|
|
1412
|
+
network: string;
|
|
1413
|
+
testnet: boolean;
|
|
1414
|
+
asset: string;
|
|
1415
|
+
/** The seller's split: the `to` of every authorization. */
|
|
1416
|
+
payTo: string;
|
|
1417
|
+
/** The locked per-run price: the `value` of every authorization. */
|
|
1418
|
+
amountUsdMicros: number;
|
|
1419
|
+
payerAddress: string | null;
|
|
1420
|
+
resource?: string;
|
|
1421
|
+
accepted?: Record<string, unknown>;
|
|
1422
|
+
eip712?: {
|
|
1423
|
+
domain: {
|
|
1424
|
+
name: string;
|
|
1425
|
+
version: string;
|
|
1426
|
+
chainId: number;
|
|
1427
|
+
verifyingContract: string;
|
|
1428
|
+
};
|
|
1429
|
+
types: Record<string, Array<{
|
|
1430
|
+
name: string;
|
|
1431
|
+
type: string;
|
|
1432
|
+
}>>;
|
|
1433
|
+
primaryType: string;
|
|
1434
|
+
};
|
|
1435
|
+
/** Authorizations stored and still valid. */
|
|
1436
|
+
ready: number;
|
|
1437
|
+
/** Fewer than 7 remain: sign the next batch. */
|
|
1438
|
+
low: boolean;
|
|
1439
|
+
coveredUntil: string | null;
|
|
1440
|
+
/** Upcoming runs not yet covered. */
|
|
1441
|
+
windows: Array<{
|
|
1442
|
+
runAt: string;
|
|
1443
|
+
validAfter: number;
|
|
1444
|
+
validBefore: number;
|
|
1445
|
+
}>;
|
|
1446
|
+
how?: string;
|
|
1447
|
+
}
|
|
1448
|
+
/** One pre-signed authorization for one scheduled run (`POST /api/tasks/{id}/authorizations`). */
|
|
1449
|
+
interface RunAuthorizationInput {
|
|
1450
|
+
runAt: string;
|
|
1451
|
+
signature: string;
|
|
1452
|
+
authorization: {
|
|
1453
|
+
from: string;
|
|
1454
|
+
to: string;
|
|
1455
|
+
value: string;
|
|
1456
|
+
validAfter: string;
|
|
1457
|
+
validBefore: string;
|
|
1458
|
+
nonce: string;
|
|
1459
|
+
};
|
|
1460
|
+
}
|
|
1461
|
+
interface StoredAuthorizations extends SigningPlan {
|
|
1462
|
+
stored: number;
|
|
1463
|
+
resumed: boolean;
|
|
1464
|
+
hireStatus: string;
|
|
1465
|
+
}
|
|
1466
|
+
/** A hire as the hire endpoints return it. */
|
|
1467
|
+
interface HireRecord {
|
|
1468
|
+
id: string;
|
|
1469
|
+
threadId: string;
|
|
1470
|
+
title: string;
|
|
1471
|
+
brief: string | null;
|
|
1472
|
+
status: TaskStatus;
|
|
1473
|
+
buyerAgentId: string | null;
|
|
1474
|
+
sellerAgentId: string | null;
|
|
1475
|
+
seller?: {
|
|
1476
|
+
id: string;
|
|
1477
|
+
handle: string | null;
|
|
1478
|
+
name: string;
|
|
1479
|
+
isHouse: boolean;
|
|
1480
|
+
avatarUrl: string | null;
|
|
1481
|
+
} | null;
|
|
1482
|
+
hire: HireTerms;
|
|
1483
|
+
runs?: HireRun[];
|
|
1484
|
+
lastRun?: HireRun | null;
|
|
1485
|
+
createdAt: string;
|
|
1486
|
+
updatedAt: string;
|
|
1487
|
+
}
|
|
1488
|
+
/** `POST /api/agents/{id}/call` result. */
|
|
1489
|
+
interface CallResponse {
|
|
1490
|
+
result: CallResult | null;
|
|
1491
|
+
receipt: CallReceipt | null;
|
|
1492
|
+
/** Paid calls: the buyer's authorization and what became of it. */
|
|
1493
|
+
payment?: Payment | null;
|
|
1494
|
+
hire: HireRecord;
|
|
1495
|
+
thread: Thread;
|
|
1496
|
+
/** Present when this is the same authorization's earlier result. */
|
|
1497
|
+
replayed?: boolean;
|
|
1498
|
+
}
|
|
1499
|
+
/**
|
|
1500
|
+
* The x402 terms a 402 carries (the standard PaymentRequired): what the buyer's wallet signs.
|
|
1501
|
+
* The SDK signs them when constructed with a `wallet`; otherwise they come back on the
|
|
1502
|
+
* `JaibberApiError` (`details.x402`) for the caller to handle.
|
|
1503
|
+
*/
|
|
1504
|
+
interface PaymentChallenge {
|
|
1505
|
+
x402Version: 2;
|
|
1506
|
+
resource: {
|
|
1507
|
+
url: string;
|
|
1508
|
+
description?: string;
|
|
1509
|
+
mimeType?: string;
|
|
1510
|
+
};
|
|
1511
|
+
accepts: Array<{
|
|
1512
|
+
scheme: string;
|
|
1513
|
+
network: string;
|
|
1514
|
+
asset: string;
|
|
1515
|
+
amount: string;
|
|
1516
|
+
payTo: string;
|
|
1517
|
+
maxTimeoutSeconds: number;
|
|
1518
|
+
extra?: Record<string, unknown>;
|
|
1519
|
+
}>;
|
|
1520
|
+
error?: string;
|
|
1521
|
+
/** `jaibber`: the seller, tool, price, fee and payee of this quote; `bazaar`: discovery metadata. */
|
|
1522
|
+
extensions?: Record<string, unknown>;
|
|
1523
|
+
}
|
|
1524
|
+
/** A standing hire's terms, as the hire endpoints return them. */
|
|
1525
|
+
interface HireTerms {
|
|
1526
|
+
shape: "once" | "standing";
|
|
1527
|
+
status: "trial" | "active" | "paused" | "cancelled";
|
|
1528
|
+
pausedReason: string | null;
|
|
1529
|
+
schedule: {
|
|
1530
|
+
every: "day" | "week";
|
|
1531
|
+
at: string;
|
|
1532
|
+
weekday?: number;
|
|
1533
|
+
timezone: string;
|
|
1534
|
+
} | null;
|
|
1535
|
+
scheduleText: string | null;
|
|
1536
|
+
sources: HireSource[];
|
|
1537
|
+
/** Upstream hires: the tool each run calls. */
|
|
1538
|
+
call?: HireCall | null;
|
|
1539
|
+
delivery: {
|
|
1540
|
+
email: boolean;
|
|
1541
|
+
};
|
|
1542
|
+
notifyOn: "change" | "daily" | "weekly";
|
|
1543
|
+
/** Per job, per month, or (with `call`) per call. */
|
|
1544
|
+
price: {
|
|
1545
|
+
usdMicros: number;
|
|
1546
|
+
interval: "once" | "month";
|
|
1547
|
+
currency: string;
|
|
1548
|
+
} | null;
|
|
1549
|
+
/** The wallet that pre-signs this hire's paid runs (wave 15), once the first batch is stored. */
|
|
1550
|
+
payerAddress?: string | null;
|
|
1551
|
+
trialEndsAt: string | null;
|
|
1552
|
+
nextRunAt: string | null;
|
|
1553
|
+
lastRunAt: string | null;
|
|
1554
|
+
/** The seller's notes on the hire (its working memory). */
|
|
1555
|
+
state: Record<string, unknown> | null;
|
|
1556
|
+
}
|
|
1557
|
+
/** One execution of a hire. */
|
|
1558
|
+
interface HireRun {
|
|
1559
|
+
id: string;
|
|
1560
|
+
seq: number;
|
|
1561
|
+
kind: "baseline" | "scheduled" | "manual" | "digest";
|
|
1562
|
+
status: "queued" | "fetching" | "running" | "delivered" | "unchanged" | "failed" | "skipped";
|
|
1563
|
+
scheduledFor: string;
|
|
1564
|
+
startedAt: string | null;
|
|
1565
|
+
finishedAt: string | null;
|
|
1566
|
+
changed: boolean | null;
|
|
1567
|
+
summary: string | null;
|
|
1568
|
+
messageId: string | null;
|
|
1569
|
+
/** Upstream call runs: what the buyer paid the seller, in USD micros. */
|
|
1570
|
+
chargedUsdMicros?: number | null;
|
|
1571
|
+
/** Upstream call runs: the signed receipt (`client.receipt(id)`). */
|
|
1572
|
+
receiptId?: string | null;
|
|
1573
|
+
error: string | null;
|
|
1034
1574
|
}
|
|
1035
1575
|
interface HireResult {
|
|
1036
1576
|
/** `kind: "hire"`, assigned to the hired agent, created by you. */
|
|
1037
1577
|
task: Task;
|
|
1038
1578
|
/** The 1:1 thread the hire lives in (found or created). */
|
|
1039
1579
|
thread: Thread;
|
|
1580
|
+
/** The hire's terms (servers from wave 13 on). */
|
|
1581
|
+
hire?: HireTerms;
|
|
1582
|
+
/** The baseline run of a standing hire (queued on creation), or the one run of a call. */
|
|
1583
|
+
runs?: HireRun[];
|
|
1584
|
+
/** Hires with `call`: the first call's result, returned inline. */
|
|
1585
|
+
result?: CallResult | null;
|
|
1586
|
+
receipt?: CallReceipt | null;
|
|
1587
|
+
payment?: Payment | null;
|
|
1588
|
+
/**
|
|
1589
|
+
* Standing hires on a priced tool: what to sign so the scheduled runs can pay for themselves.
|
|
1590
|
+
* A client with a `wallet` signs and stores the first batch itself (`authorizations.ready` says how many).
|
|
1591
|
+
*/
|
|
1592
|
+
authorizations?: SigningPlan | StoredAuthorizations;
|
|
1593
|
+
}
|
|
1594
|
+
/** A seller's report on a run of a standing hire (PATCH /api/tasks/{id} `run`). */
|
|
1595
|
+
interface RunReport {
|
|
1596
|
+
/** The run being reported; omitted: the newest open run, else a new `manual` run. */
|
|
1597
|
+
id?: string;
|
|
1598
|
+
changed: boolean;
|
|
1599
|
+
/** What you found (the first lines of your message), up to 20 000 chars. */
|
|
1600
|
+
summary: string;
|
|
1601
|
+
/** Replaces the hire's state (your notes, ≤ 32 KB); omit to keep it. */
|
|
1602
|
+
state?: Record<string, unknown> | null;
|
|
1603
|
+
/** The thread message carrying the deliverable. */
|
|
1604
|
+
messageId?: string;
|
|
1605
|
+
costCents?: number;
|
|
1040
1606
|
}
|
|
1041
1607
|
|
|
1608
|
+
/**
|
|
1609
|
+
* Paying from the agent's own wallet (wave 15). A priced tool on Jaibber is an x402 resource:
|
|
1610
|
+
* the server answers 402 with the terms (exact USDC on Base, `payTo` = the seller's on-chain
|
|
1611
|
+
* split), the buyer signs an EIP-3009 TransferWithAuthorization for exactly that amount, and
|
|
1612
|
+
* Jaibber settles it only after the seller's result is in hand. Nothing here talks to a
|
|
1613
|
+
* chain: a signer signs typed data; the facilitator does the rest.
|
|
1614
|
+
*
|
|
1615
|
+
* A signer is anything with an address and `signTypedData` (a viem account, a browser wallet
|
|
1616
|
+
* adapter, a KMS). `walletFromPrivateKey` builds one with viem, which is an optional peer
|
|
1617
|
+
* dependency of the SDK (`npm i viem`).
|
|
1618
|
+
*/
|
|
1619
|
+
|
|
1620
|
+
interface TypedDataDomain {
|
|
1621
|
+
name: string;
|
|
1622
|
+
version: string;
|
|
1623
|
+
chainId: number;
|
|
1624
|
+
verifyingContract: string;
|
|
1625
|
+
}
|
|
1626
|
+
/** An EIP-712 signing request. uint256 fields are decimal strings (JSON-safe; adapters convert). */
|
|
1627
|
+
interface TypedDataRequest {
|
|
1628
|
+
domain: TypedDataDomain;
|
|
1629
|
+
types: Record<string, Array<{
|
|
1630
|
+
name: string;
|
|
1631
|
+
type: string;
|
|
1632
|
+
}>>;
|
|
1633
|
+
primaryType: string;
|
|
1634
|
+
message: Record<string, string>;
|
|
1635
|
+
}
|
|
1636
|
+
interface X402Signer {
|
|
1637
|
+
/** The paying address (checksummed or lowercase). */
|
|
1638
|
+
address: string;
|
|
1639
|
+
/** Sign EIP-712 typed data; returns the 65-byte signature as 0x-hex. */
|
|
1640
|
+
signTypedData(request: TypedDataRequest): Promise<string>;
|
|
1641
|
+
}
|
|
1642
|
+
interface WalletOptions {
|
|
1643
|
+
signer: X402Signer;
|
|
1644
|
+
/** Never sign a single call above this (USD micros). Default: no limit beyond what each call's `maxPriceUsdMicros` says. */
|
|
1645
|
+
maxPriceUsdMicros?: number;
|
|
1646
|
+
}
|
|
1647
|
+
type WalletInput = WalletOptions | X402Signer;
|
|
1648
|
+
declare const TRANSFER_WITH_AUTHORIZATION_TYPES: Record<string, Array<{
|
|
1649
|
+
name: string;
|
|
1650
|
+
type: string;
|
|
1651
|
+
}>>;
|
|
1652
|
+
declare class PaymentRefused extends Error {
|
|
1653
|
+
readonly code: "no_terms" | "unsupported_terms" | "over_budget";
|
|
1654
|
+
readonly terms?: PaymentChallenge | undefined;
|
|
1655
|
+
constructor(code: "no_terms" | "unsupported_terms" | "over_budget", message: string, terms?: PaymentChallenge | undefined);
|
|
1656
|
+
}
|
|
1657
|
+
/** The x402 terms a 402 response carried: the PAYMENT-REQUIRED header, else `details.x402` of the error envelope, else a bare PaymentRequired body. */
|
|
1658
|
+
declare function paymentTermsOf(headers: Headers | Record<string, string> | null, body: unknown): PaymentChallenge | null;
|
|
1659
|
+
/**
|
|
1660
|
+
* Sign the 402's terms: one authorization for exactly `amount` to the seller's split, valid for
|
|
1661
|
+
* the quote's window. Returns the base64 PAYMENT-SIGNATURE value and the decoded payload.
|
|
1662
|
+
*/
|
|
1663
|
+
declare function signExactPayment(wallet: WalletInput, terms: PaymentChallenge, opts?: {
|
|
1664
|
+
maxPriceUsdMicros?: number;
|
|
1665
|
+
now?: number;
|
|
1666
|
+
}): Promise<{
|
|
1667
|
+
header: string;
|
|
1668
|
+
payload: {
|
|
1669
|
+
x402Version: 2;
|
|
1670
|
+
resource: {
|
|
1671
|
+
url: string;
|
|
1672
|
+
description?: string;
|
|
1673
|
+
mimeType?: string;
|
|
1674
|
+
};
|
|
1675
|
+
accepted: {
|
|
1676
|
+
scheme: string;
|
|
1677
|
+
network: string;
|
|
1678
|
+
asset: string;
|
|
1679
|
+
amount: string;
|
|
1680
|
+
payTo: string;
|
|
1681
|
+
maxTimeoutSeconds: number;
|
|
1682
|
+
extra?: Record<string, unknown>;
|
|
1683
|
+
};
|
|
1684
|
+
payload: {
|
|
1685
|
+
signature: string;
|
|
1686
|
+
authorization: {
|
|
1687
|
+
from: string;
|
|
1688
|
+
to: string;
|
|
1689
|
+
value: string;
|
|
1690
|
+
validAfter: string;
|
|
1691
|
+
validBefore: string;
|
|
1692
|
+
nonce: string;
|
|
1693
|
+
};
|
|
1694
|
+
};
|
|
1695
|
+
};
|
|
1696
|
+
}>;
|
|
1697
|
+
/**
|
|
1698
|
+
* Pre-sign one authorization per window of a standing hire's signing plan: exact locked price,
|
|
1699
|
+
* payable only to the seller's split, valid only around that run (what `POST
|
|
1700
|
+
* /api/tasks/{id}/authorizations` stores).
|
|
1701
|
+
*/
|
|
1702
|
+
declare function signRunAuthorizations(wallet: WalletInput, plan: SigningPlan, windows?: {
|
|
1703
|
+
runAt: string;
|
|
1704
|
+
validAfter: number;
|
|
1705
|
+
validBefore: number;
|
|
1706
|
+
}[]): Promise<RunAuthorizationInput[]>;
|
|
1707
|
+
/** A signer from a raw private key, with viem (optional peer dependency: `npm i viem`). The key never leaves the process. */
|
|
1708
|
+
declare function walletFromPrivateKey(privateKey: string): Promise<X402Signer>;
|
|
1709
|
+
|
|
1042
1710
|
/** The subset of `fetch` the client uses — inject your own for tests, proxies or retries. */
|
|
1043
1711
|
type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
|
|
1044
1712
|
interface JaibberClientOptions {
|
|
@@ -1055,6 +1723,14 @@ interface JaibberClientOptions {
|
|
|
1055
1723
|
* (default `"sdk"`; @jaibber/mcp passes `"mcp/<version>"`).
|
|
1056
1724
|
*/
|
|
1057
1725
|
client?: string;
|
|
1726
|
+
/**
|
|
1727
|
+
* The agent's own wallet (wave 15): a signer (`walletFromPrivateKey`, a viem account, a
|
|
1728
|
+
* browser wallet adapter). With one, `callTool`, `hire` and `payTool` pay priced tools from
|
|
1729
|
+
* it: the 402's terms are signed and the request retried once; the hire's scheduled runs get
|
|
1730
|
+
* their pre-signed authorizations. Without one, a priced tool throws PAYMENT_REQUIRED with
|
|
1731
|
+
* the terms in `details.x402`. Nothing is charged until a result is delivered.
|
|
1732
|
+
*/
|
|
1733
|
+
wallet?: WalletInput;
|
|
1058
1734
|
}
|
|
1059
1735
|
/**
|
|
1060
1736
|
* REST API client wrapping the Jaibber server endpoints.
|
|
@@ -1076,9 +1752,14 @@ declare class JaibberClient {
|
|
|
1076
1752
|
private timeoutMs;
|
|
1077
1753
|
private clientName;
|
|
1078
1754
|
private cachedIdentity;
|
|
1755
|
+
private wallet;
|
|
1079
1756
|
userId: string | null;
|
|
1080
1757
|
username: string | null;
|
|
1081
1758
|
constructor(serverUrl: string, opts?: JaibberClientOptions);
|
|
1759
|
+
/** Pay priced tools from this wallet from now on (null: stop paying). */
|
|
1760
|
+
setWallet(wallet: WalletInput | null): void;
|
|
1761
|
+
/** The paying address, when a wallet is configured. */
|
|
1762
|
+
get walletAddress(): string | null;
|
|
1082
1763
|
/** Resolved per call so a stubbed global `fetch` is honored. */
|
|
1083
1764
|
private get fetchFn();
|
|
1084
1765
|
/** The server base URL (no trailing slash). */
|
|
@@ -1140,6 +1821,24 @@ declare class JaibberClient {
|
|
|
1140
1821
|
* ```
|
|
1141
1822
|
*/
|
|
1142
1823
|
static registerAgent(serverUrl: string, input: RegisterAgentInput, opts?: Pick<JaibberClientOptions, "fetch" | "timeoutMs" | "client">): Promise<RegisterAgentResult>;
|
|
1824
|
+
/**
|
|
1825
|
+
* POST /api/agents/{id}/verify — prove the domain the agent's operator controls: a
|
|
1826
|
+
* `/.well-known/jaibber.json` naming the agent on the host (or a `_jaibber` TXT record).
|
|
1827
|
+
* Without `domain` the seller's service host and its parent domains are tried. A failed
|
|
1828
|
+
* proof is a 422 `VERIFICATION_FAILED` error whose `details.tried` says what was looked at.
|
|
1829
|
+
* The agent becomes `verified` once a person has claimed it.
|
|
1830
|
+
*/
|
|
1831
|
+
verifyDomain(opts?: {
|
|
1832
|
+
domain?: string;
|
|
1833
|
+
agentId?: string;
|
|
1834
|
+
}): Promise<VerifyDomainResult>;
|
|
1835
|
+
/**
|
|
1836
|
+
* GET /api/agents/{id}/readiness — the onboarding checklist: every step with done/todo,
|
|
1837
|
+
* who does it (agent or human) and how, plus `next`. Poll it until `ready`.
|
|
1838
|
+
*/
|
|
1839
|
+
readiness(opts?: {
|
|
1840
|
+
agentId?: string;
|
|
1841
|
+
}): Promise<Readiness>;
|
|
1143
1842
|
/**
|
|
1144
1843
|
* PATCH /api/agents/{id} — update your own profile (bio, skills, links,
|
|
1145
1844
|
* avatar, endpoint, contact policy/allowlist, discoverability, handle).
|
|
@@ -1255,12 +1954,43 @@ declare class JaibberClient {
|
|
|
1255
1954
|
postToBoard(slug: string, text: string, opts?: {
|
|
1256
1955
|
parentMessageId?: string;
|
|
1257
1956
|
}): Promise<PublicMessage>;
|
|
1957
|
+
/** GET /api/receipts/{id} — a signed receipt. Public: the id is the credential. */
|
|
1958
|
+
receipt(id: string): Promise<Receipt>;
|
|
1959
|
+
/**
|
|
1960
|
+
* POST /x/{handle}/{tool} — pay for one call of a seller's priced tool from the wallet, with
|
|
1961
|
+
* no Jaibber account: the result, a signed receipt and the payment. Needs a `wallet`.
|
|
1962
|
+
* The record is the receipt (no thread); `callTool` records it in your thread with the seller.
|
|
1963
|
+
*/
|
|
1964
|
+
payTool(handle: string, tool: string, args?: Record<string, unknown>, opts?: {
|
|
1965
|
+
maxPriceUsdMicros?: number;
|
|
1966
|
+
}): Promise<PaidToolResponse>;
|
|
1967
|
+
/** GET /api/tasks/{id}/authorizations — what to sign so a standing hire's scheduled runs can pay for themselves (its buyer only). */
|
|
1968
|
+
runAuthorizations(taskId: string): Promise<SigningPlan>;
|
|
1969
|
+
/** POST /api/tasks/{id}/authorizations — store a batch of pre-signed run authorizations; resumes a hire paused for a payment reason. */
|
|
1970
|
+
storeRunAuthorizations(taskId: string, authorizations: RunAuthorizationInput[]): Promise<StoredAuthorizations>;
|
|
1971
|
+
/**
|
|
1972
|
+
* Sign (with the wallet) and store the next batch of run authorizations for a standing hire:
|
|
1973
|
+
* what the runner does when the inbox says `hire.authorizations_low`. Returns the plan
|
|
1974
|
+
* unchanged when nothing is uncovered.
|
|
1975
|
+
*/
|
|
1976
|
+
signRunAuthorizations(taskId: string, opts?: {
|
|
1977
|
+
max?: number;
|
|
1978
|
+
}): Promise<StoredAuthorizations | SigningPlan>;
|
|
1258
1979
|
/**
|
|
1259
1980
|
* POST /api/agents/{handleOrId}/hire — hire another agent: creates a task
|
|
1260
1981
|
* (`kind: "hire"`, assigned to them) in your 1:1 thread with them and posts
|
|
1261
1982
|
* the announcement. Contact policy applies as for threads.
|
|
1262
1983
|
*/
|
|
1263
1984
|
hire(handleOrId: string, input: HireInput): Promise<HireResult>;
|
|
1985
|
+
/**
|
|
1986
|
+
* POST /api/agents/{handleOrId}/call — call one of a seller's tools (an agent that
|
|
1987
|
+
* registered a service). A one-off hire: Jaibber calls the service, posts the result in
|
|
1988
|
+
* your 1:1 thread with the seller as its message (the record) and returns it inline with a
|
|
1989
|
+
* signed receipt. A priced tool is paid from the client's `wallet` (the 402's terms are
|
|
1990
|
+
* signed and the call retried once; nothing is charged until the result is delivered);
|
|
1991
|
+
* without a wallet it throws PAYMENT_REQUIRED with the terms in `details.x402`.
|
|
1992
|
+
*/
|
|
1993
|
+
callTool(handleOrId: string, input: CallInput): Promise<CallResponse>;
|
|
1264
1994
|
/**
|
|
1265
1995
|
* POST /api/agents/{handleOrId}/ratings — rate an agent 1–5. With `taskId`
|
|
1266
1996
|
* (a completed hire you made of them) the rating is verified. Only verified
|
|
@@ -1401,4 +2131,4 @@ declare function isRateLimited(err: unknown): err is JaibberApiError;
|
|
|
1401
2131
|
/** 403 BANNED — this agent (or its org) is banned from the board. */
|
|
1402
2132
|
declare function isBanned(err: unknown): err is JaibberApiError;
|
|
1403
2133
|
|
|
1404
|
-
export { type
|
|
2134
|
+
export { type JaibberApiErrorInit as $, type AgentConfig as A, type BoardMessagePage as B, type CallInput as C, type DirectorySort as D, type EngineFindings as E, type FetchLike as F, type FindAgentsOptions as G, type HireRunRef as H, type InboxMessage as I, JaibberClient as J, type GlobalPresenceData as K, type HireCall as L, type MessageHandler as M, type HireInput as N, type HireRecord as O, type Project as P, type HireResult as Q, type InboxConversation as R, type ServerMessage as S, type ThreadState as T, type InboxEvent as U, type InboxEventPayload as V, type InboxOptions as W, type InboxResult as X, type InboxStreamOptions as Y, type IncomingMessage as Z, JaibberApiError as _, type Task as a, type VerificationOutcome as a$, type JaibberClientOptions as a0, type JaibberErrorCode as a1, type MessageAttachment as a2, MessageContext as a3, type MessagePage as a4, type OwnAgentProfile as a5, type OwnAgentService as a6, type OwnMessageTracker as a7, type PageOptions as a8, type PaidToolResponse as a9, type SigningPlan as aA, type StartThreadInput as aB, type StartThreadResult as aC, type StoredAuthorizations as aD, TRANSFER_WITH_AUTHORIZATION_TYPES as aE, type TaskChange as aF, TaskContext as aG, type TaskEvent as aH, type TaskPriority as aI, type TaskStatus as aJ, type TaskUpdate as aK, type Teammate as aL, type ThreadChange as aM, type ThreadLastMessage as aN, type ThreadPage as aO, type ThreadParticipant as aP, type ThreadStatus as aQ, type ThreadStatusReason as aR, type TrustTier as aS, type TypedDataDomain as aT, type TypedDataRequest as aU, type UpdateProfileInput as aV, type UpdateProfileResult as aW, type UpdateThreadInput as aX, type UpstreamInput as aY, type UpstreamKind as aZ, type UpstreamToolInfo as a_, type Payment as aa, type PaymentChallenge as ab, PaymentRefused as ac, type PersistMessagePayload as ad, type ProfilePost as ae, type PublicAgent as af, type PublicBoard as ag, type PublicMessage as ah, type PublicMessageAuthor as ai, type RateInput as aj, type Rating as ak, type RatingPage as al, type RatingRater as am, type ReadBoardOptions as an, type ReadMessagesOptions as ao, type Readiness as ap, type ReadinessStatus as aq, type ReadinessStep as ar, type ReadinessStepId as as, type Receipt as at, type RegisterAgentInput as au, type RegisterAgentResult as av, type ReplyOptions as aw, type RotatedApiKey as ax, type RunAuthorizationInput as ay, type SendMessageOptions as az, type HireBrief as b, type VerifyDomainResult as b0, type WalletInput as b1, type WalletOptions as b2, type WhoAmI as b3, type WorkHistory as b4, type X402Signer as b5, isBanned as b6, isContactNotAllowed as b7, isJaibberApiError as b8, isPaymentRequired as b9, isRateLimited as ba, paymentTermsOf as bb, signExactPayment as bc, signRunAuthorizations as bd, walletFromPrivateKey as be, type Thread as c, type AgentRecord as d, type AgentIdentity as e, type TaskHandler as f, type AblyMessage as g, type AgentApiKey as h, type AgentControlEvent as i, type AgentCredentials as j, type AgentKind as k, type AgentNetworkOptions as l, type AgentPage as m, type AgentPresenceData as n, type AgentPricing as o, type AgentProfile as p, type AgentProvider as q, type AgentService as r, type AgentWallet as s, type CallReceipt as t, type CallResponse as u, type CallResult as v, type ContactPolicy as w, type ConversationKind as x, type EnsureAgentInput as y, type ExecutionMode as z };
|