@lucid-agents/taskmarket 1.35.0 → 1.37.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/agent-compatibility.json +1 -1
- package/dist/{api-R76D244Y.js → api-X7M5ZRFO.js} +2 -2
- package/dist/{channels-SVCU2MU5.js → channels-JRY5YSNU.js} +4 -4
- package/dist/{chunk-CHX7O7EU.js → chunk-5YGFSGJA.js} +1 -1
- package/dist/{chunk-WP7GXSKE.js → chunk-ATZLUOQX.js} +3 -3
- package/dist/{chunk-QAGDCIMU.js → chunk-AUDDFWKQ.js} +372 -117
- package/dist/{chunk-KHDQRFHG.js → chunk-HNTWHQBL.js} +5 -5
- package/dist/{chunk-JRWRBSS2.js → chunk-IDSGZXDR.js} +3 -3
- package/dist/{chunk-YGSVDU2D.js → chunk-M2UVDGSH.js} +3 -3
- package/dist/{chunk-B7W4G3EY.js → chunk-NO227FAP.js} +1 -1
- package/dist/{chunk-L6D2CDVQ.js → chunk-OK3AHSZH.js} +8 -8
- package/dist/{chunk-BDKM5JMT.js → chunk-SKD2T3UR.js} +1 -1
- package/dist/{chunk-54OR2JDT.js → chunk-TDQHU2JT.js} +2 -2
- package/dist/{chunk-G3U2BQNC.js → chunk-XL76RC3P.js} +1 -1
- package/dist/{chunk-YHVP2UNE.js → chunk-YQLA6EXP.js} +1 -1
- package/dist/{doctor-IIVQFDIB.js → doctor-QGHPARVU.js} +8 -8
- package/dist/index.js +393 -84
- package/dist/{launch-OC4LIPSS.js → launch-6VCLZ7XR.js} +11 -11
- package/dist/pi-extensions/xgate.cjs +155 -3
- package/dist/{read-auth-AGP3CUMT.js → read-auth-AVN4SJSZ.js} +3 -3
- package/dist/{reconcile-H3JIKN2X.js → reconcile-HEON5ETE.js} +4 -4
- package/dist/{status-SARVECVT.js → status-6PCJLCTM.js} +8 -8
- package/dist/{sync-pull-IUPV57MU.js → sync-pull-62R4YTEO.js} +4 -4
- package/dist/{task-access-grants-HALV3NEO.js → task-access-grants-MIWSFZZ3.js} +2 -2
- package/package.json +1 -1
|
@@ -641,7 +641,8 @@ var WALLET_WRITE_MESSAGE_HEADERS = {
|
|
|
641
641
|
"bug-report": "Taskmarket: bug report write v1",
|
|
642
642
|
"bookmark-collection": "Taskmarket: bookmark collection write v1",
|
|
643
643
|
"tap-key": "Taskmarket: TAP key enrolment v1",
|
|
644
|
-
"user-skill": "Taskmarket: user skill write v1"
|
|
644
|
+
"user-skill": "Taskmarket: user skill write v1",
|
|
645
|
+
"listing-submission": "Taskmarket: listing submission v1"
|
|
645
646
|
};
|
|
646
647
|
var MARKET_EVENT_SETTINGS_WRITE_MESSAGE_HEADER = WALLET_WRITE_MESSAGE_HEADERS["market-event-settings"];
|
|
647
648
|
var WALLET_WRITE_MAX_TTL_SECONDS = 15 * 60;
|
|
@@ -9512,6 +9513,10 @@ var ProjectWorkflowDeleteSchema = z53.object({
|
|
|
9512
9513
|
chainId: ChainIdSchema4.optional(),
|
|
9513
9514
|
workflowId: z53.string().uuid()
|
|
9514
9515
|
});
|
|
9516
|
+
var ProjectWorkflowUpdateTemplateSchema = z53.object({
|
|
9517
|
+
chainId: ChainIdSchema4.optional(),
|
|
9518
|
+
workflowId: z53.string().uuid()
|
|
9519
|
+
});
|
|
9515
9520
|
var ProjectWorkflowRunActionSchema = z53.object({
|
|
9516
9521
|
chainId: ChainIdSchema4.optional(),
|
|
9517
9522
|
runId: z53.string().uuid()
|
|
@@ -9538,7 +9543,14 @@ var WorkflowTemplateKindSchema = z53.enum(["template", "preset"]);
|
|
|
9538
9543
|
var ProjectWorkflowSourceSchema = z53.object({
|
|
9539
9544
|
kind: WorkflowTemplateKindSchema,
|
|
9540
9545
|
templateId: z53.string().describe("The template id, or the preset name"),
|
|
9541
|
-
params: z53.record(z53.union([z53.string(), z53.number(), z53.array(z53.string())]))
|
|
9546
|
+
params: z53.record(z53.union([z53.string(), z53.number(), z53.array(z53.string())])),
|
|
9547
|
+
templateVersion: z53.string().optional().describe("The template's version when the workflow was made or last updated from it; absent on a workflow made before versions were recorded")
|
|
9548
|
+
});
|
|
9549
|
+
var ProjectWorkflowTemplateUpdateStatusSchema = z53.object({
|
|
9550
|
+
templateId: z53.string(),
|
|
9551
|
+
currentVersion: z53.string().nullable().describe("The version the workflow has; null when not recorded"),
|
|
9552
|
+
latestVersion: z53.string().nullable().describe("The template now; null when it was deleted"),
|
|
9553
|
+
available: z53.boolean().describe("True when the template has a version other than the one the workflow has")
|
|
9542
9554
|
});
|
|
9543
9555
|
var ProjectWorkflowViewSchema = z53.object({
|
|
9544
9556
|
workflowId: z53.string(),
|
|
@@ -9549,6 +9561,7 @@ var ProjectWorkflowViewSchema = z53.object({
|
|
|
9549
9561
|
document: z53.record(z53.unknown()).describe("The validated document, with every default filled in"),
|
|
9550
9562
|
summary: WorkflowSummarySchema,
|
|
9551
9563
|
source: ProjectWorkflowSourceSchema.nullable().describe("The template or preset it was made from, with its parameter values; null when written by hand"),
|
|
9564
|
+
templateUpdate: ProjectWorkflowTemplateUpdateStatusSchema.nullable().optional().describe("Whether the template it was made from has another version now (available); null for a workflow written by hand. Filled by the list, show and update-template reads"),
|
|
9552
9565
|
createdAt: z53.string()
|
|
9553
9566
|
});
|
|
9554
9567
|
var ProjectWorkflowRunStatusSchema = z53.enum([
|
|
@@ -9765,6 +9778,14 @@ var WORKFLOW_TEMPLATE_AMOUNT_MAX_DIGITS = 30;
|
|
|
9765
9778
|
var WORKFLOW_TEMPLATE_PARAMETER_DESCRIPTION_MAX = 500;
|
|
9766
9779
|
var WORKFLOW_TEMPLATE_LIST_MAX_ITEMS = WORKFLOW_MAX_ITEMS_MAX;
|
|
9767
9780
|
var WORKFLOW_TEMPLATE_LIST_ITEM_MAX_LENGTH = WORKFLOW_ITEM_MAX_LENGTH;
|
|
9781
|
+
var WORKFLOW_TEMPLATE_TAGS_MAX = 8;
|
|
9782
|
+
var WORKFLOW_TEMPLATE_TAG_MAX_LENGTH = 24;
|
|
9783
|
+
var WORKFLOW_TEMPLATE_TAG_INPUT_MAX_LENGTH = 40;
|
|
9784
|
+
var WORKFLOW_TEMPLATE_TAG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
|
|
9785
|
+
var WORKFLOW_TEMPLATE_SEARCH_MAX_LENGTH = 100;
|
|
9786
|
+
var WORKFLOW_TEMPLATE_SEARCH_TAGS_MAX = 5;
|
|
9787
|
+
var WORKFLOW_TEMPLATE_SEARCH_LIMIT_DEFAULT = 20;
|
|
9788
|
+
var WORKFLOW_TEMPLATE_SEARCH_LIMIT_MAX = 100;
|
|
9768
9789
|
var WORKFLOW_TEMPLATE_PARAMETER_NAME = /^[A-Za-z][A-Za-z0-9_]{0,39}$/;
|
|
9769
9790
|
var WORKFLOW_TEMPLATE_PARAMETER_TYPES = ["string", "integer", "amount", "list"];
|
|
9770
9791
|
var WORKFLOW_PRESET_NAMES = ["code", "content", "research"];
|
|
@@ -9777,7 +9798,8 @@ var WORKFLOW_TEMPLATE_FIXED_FIELDS = [
|
|
|
9777
9798
|
"approve",
|
|
9778
9799
|
"on",
|
|
9779
9800
|
"verdict",
|
|
9780
|
-
"when"
|
|
9801
|
+
"when",
|
|
9802
|
+
"hireWinnerOf"
|
|
9781
9803
|
];
|
|
9782
9804
|
var TemplateInputSchema = z55.record(z55.unknown()).describe("The template: { name, description?, parameters, steps }, a workflow document whose strings use {{param}} placeholders, and parameters declaring each one: { type: string | integer | amount | list, default?, description?, and bounds (min/max for integer and amount, minLength/maxLength for string, minItems/maxItems/maxLength for list) }");
|
|
9783
9805
|
var ProjectWorkflowTemplateCreateSchema = z55.object({
|
|
@@ -9793,6 +9815,10 @@ var ProjectWorkflowTemplateDeleteSchema = z55.object({
|
|
|
9793
9815
|
chainId: ChainIdSchema5.optional(),
|
|
9794
9816
|
templateId: z55.string().uuid()
|
|
9795
9817
|
});
|
|
9818
|
+
var ProjectWorkflowTemplatePublishSchema = z55.object({
|
|
9819
|
+
chainId: ChainIdSchema5.optional(),
|
|
9820
|
+
templateId: z55.string().uuid()
|
|
9821
|
+
});
|
|
9796
9822
|
var ParameterValueInputSchema = z55.union([
|
|
9797
9823
|
z55.string().max(WORKFLOW_TEMPLATE_STRING_MAX_LENGTH),
|
|
9798
9824
|
z55.number(),
|
|
@@ -9822,11 +9848,44 @@ var ProjectWorkflowTemplateViewSchema = z55.object({
|
|
|
9822
9848
|
owner: z55.string().nullable().describe("The wallet that saved it; null for a preset or an official template"),
|
|
9823
9849
|
name: z55.string(),
|
|
9824
9850
|
description: z55.string().nullable(),
|
|
9851
|
+
tags: z55.array(z55.string()).describe("Normalized tags the author (or the repository, for an official template) gave it"),
|
|
9852
|
+
featured: z55.boolean().optional().describe("True for a template on the featured list, which the repository curates"),
|
|
9825
9853
|
template: z55.record(z55.unknown()).describe("The validated template: name, description, parameters (every bound filled in), steps"),
|
|
9826
9854
|
summary: WorkflowSummarySchema.describe("The workflow with every parameter at its maximum: the worst case a project must hold"),
|
|
9855
|
+
version: z55.string().describe("The template version: 1, 2, 3 ... for a saved template, bumped whenever a save changes its content; a short content hash for an official template or preset"),
|
|
9856
|
+
contentHash: z55.string().describe("SHA-256 of the template content, hex"),
|
|
9857
|
+
versions: z55.array(z55.object({
|
|
9858
|
+
version: z55.string(),
|
|
9859
|
+
contentHash: z55.string(),
|
|
9860
|
+
at: z55.string().describe("When that version was replaced")
|
|
9861
|
+
})).optional().describe("Earlier versions of a saved template, oldest first; shown on a single template only"),
|
|
9862
|
+
listed: z55.boolean().optional().describe("True when the author listed this saved template in the public gallery"),
|
|
9863
|
+
listedAt: z55.string().nullable().optional(),
|
|
9827
9864
|
createdAt: z55.string().nullable(),
|
|
9828
9865
|
updatedAt: z55.string().nullable()
|
|
9829
9866
|
});
|
|
9867
|
+
var SearchTagSchema = z55.string().min(1).max(WORKFLOW_TEMPLATE_TAG_INPUT_MAX_LENGTH).describe("A tag as written; it is normalized (lowercase, hyphens) before it is matched");
|
|
9868
|
+
var WORKFLOW_TEMPLATE_SEARCH_SORTS = ["featured", "name"];
|
|
9869
|
+
var WORKFLOW_TEMPLATE_SEARCH_SCOPES = ["all", "saved", "community"];
|
|
9870
|
+
var ProjectWorkflowTemplateSearchSchema = z55.object({
|
|
9871
|
+
q: z55.string().trim().min(1).max(WORKFLOW_TEMPLATE_SEARCH_MAX_LENGTH).optional().describe(`Words to find in a template's name, description or tags; every word must match (at most ${WORKFLOW_TEMPLATE_SEARCH_MAX_LENGTH} characters)`),
|
|
9872
|
+
tags: csvArrayQueryParam(SearchTagSchema, {
|
|
9873
|
+
maxItems: WORKFLOW_TEMPLATE_SEARCH_TAGS_MAX
|
|
9874
|
+
}).describe(`Comma-separated tags; a template must carry all of them (at most ${WORKFLOW_TEMPLATE_SEARCH_TAGS_MAX})`),
|
|
9875
|
+
// A query-string flag, so it arrives as 'true' or 'false' over REST.
|
|
9876
|
+
featured: z55.enum(["true", "false"]).optional().transform((value) => value === void 0 ? void 0 : value === "true").describe("true lists only the featured templates"),
|
|
9877
|
+
owner: z55.string().regex(/^0x[0-9a-fA-F]{40}$/, "owner is a wallet address (0x and 40 hex digits)").optional().describe("Also search this wallet's saved templates, listed after the catalog"),
|
|
9878
|
+
scope: z55.enum(WORKFLOW_TEMPLATE_SEARCH_SCOPES).default("all").describe("all: the catalog, then owner's saved templates, or with no owner the templates listed in the gallery; saved: only owner's (needs owner); community: only the gallery's listed templates"),
|
|
9879
|
+
sort: z55.enum(WORKFLOW_TEMPLATE_SEARCH_SORTS).default("featured").describe("featured: featured, then other official templates, presets, then saved templates newest first; name: A to Z within the catalog, then saved templates A to Z"),
|
|
9880
|
+
limit: coerceNumber(z55.number().int().min(1).max(WORKFLOW_TEMPLATE_SEARCH_LIMIT_MAX)).default(WORKFLOW_TEMPLATE_SEARCH_LIMIT_DEFAULT),
|
|
9881
|
+
cursor: z55.string().min(1).max(300).optional().describe("nextCursor from the previous page; valid only with the same filters and sort")
|
|
9882
|
+
});
|
|
9883
|
+
var ProjectWorkflowTemplateSearchOutputSchema = z55.object({
|
|
9884
|
+
templates: z55.array(ProjectWorkflowTemplateViewSchema),
|
|
9885
|
+
nextCursor: z55.string().nullable(),
|
|
9886
|
+
hasMore: z55.boolean(),
|
|
9887
|
+
catalogTags: z55.array(z55.object({ tag: z55.string(), count: z55.number().int() })).describe("The most used tags across the whole catalog (not this page), for a tag picker; same on every page")
|
|
9888
|
+
});
|
|
9830
9889
|
|
|
9831
9890
|
// ../../packages/shared/dist/schemas/brief-session.schemas.js
|
|
9832
9891
|
import { z as z57 } from "zod";
|
|
@@ -10523,7 +10582,8 @@ var FIELDS = {
|
|
|
10523
10582
|
"payout",
|
|
10524
10583
|
"reviewAccept",
|
|
10525
10584
|
"reviewer",
|
|
10526
|
-
"allowOpenAutoAccept"
|
|
10585
|
+
"allowOpenAutoAccept",
|
|
10586
|
+
"hireWinnerOf"
|
|
10527
10587
|
],
|
|
10528
10588
|
sequence: ["pattern", "id", "steps"],
|
|
10529
10589
|
parallel: ["pattern", "id", "steps"],
|
|
@@ -10838,6 +10898,21 @@ var Checker = class {
|
|
|
10838
10898
|
}
|
|
10839
10899
|
}
|
|
10840
10900
|
}
|
|
10901
|
+
if (pattern === "task" && raw.hireWinnerOf !== void 0) {
|
|
10902
|
+
const name = raw.hireWinnerOf;
|
|
10903
|
+
const at = pointer(path3, "hireWinnerOf");
|
|
10904
|
+
if (typeof name !== "string" || !WORKFLOW_NAME_PATTERN.test(name)) {
|
|
10905
|
+
this.error(at, "invalid_hire_winner_of", "hireWinnerOf names one of this step's inputs: the output of an earlier step whose winning worker this step hires");
|
|
10906
|
+
} else if (name === WORKFLOW_ITEM_INPUT || !inputs.includes(name)) {
|
|
10907
|
+
this.error(at, "hire_winner_not_input", `hireWinnerOf "${name}" must be one of this step's inputs (an output of an earlier step); inputs are ${inputs.length > 0 ? inputs.join(", ") : "empty"}`);
|
|
10908
|
+
} else if (template && template.mode !== "claim") {
|
|
10909
|
+
this.error(pointer(path3, "task", "mode"), "hire_needs_claim", 'A step that hires the winner of an earlier step runs in the claim mode: set task.mode to "claim"');
|
|
10910
|
+
} else if (when.reviewer !== void 0) {
|
|
10911
|
+
this.error(at, "hire_and_reviewer", "A step hires the winner of an earlier step or has a reviewer, not both");
|
|
10912
|
+
} else {
|
|
10913
|
+
when.hireWinnerOf = name;
|
|
10914
|
+
}
|
|
10915
|
+
}
|
|
10841
10916
|
outputs.forEach((name, index) => {
|
|
10842
10917
|
if (name === WORKFLOW_ITEM_INPUT) {
|
|
10843
10918
|
this.error(pointer(path3, "outputs", index), "reserved_name", `"${WORKFLOW_ITEM_INPUT}" is reserved for a forEach's item`);
|
|
@@ -11606,6 +11681,27 @@ function fundsErrors(spend, funds, path3 = "/steps") {
|
|
|
11606
11681
|
return errors;
|
|
11607
11682
|
}
|
|
11608
11683
|
|
|
11684
|
+
// ../../packages/shared/dist/lib/workflow-template-search.js
|
|
11685
|
+
function normalizeWorkflowTemplateTag(raw) {
|
|
11686
|
+
if (raw.length > WORKFLOW_TEMPLATE_TAG_INPUT_MAX_LENGTH)
|
|
11687
|
+
return null;
|
|
11688
|
+
const tag = raw.trim().toLowerCase().replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
|
|
11689
|
+
if (tag.length === 0 || tag.length > WORKFLOW_TEMPLATE_TAG_MAX_LENGTH)
|
|
11690
|
+
return null;
|
|
11691
|
+
return WORKFLOW_TEMPLATE_TAG.test(tag) ? tag : null;
|
|
11692
|
+
}
|
|
11693
|
+
function normalizeWorkflowTemplateTags(raw) {
|
|
11694
|
+
const tags = [];
|
|
11695
|
+
for (const value of raw) {
|
|
11696
|
+
const tag = normalizeWorkflowTemplateTag(value);
|
|
11697
|
+
if (tag === null)
|
|
11698
|
+
return { ok: false, invalid: value };
|
|
11699
|
+
if (!tags.includes(tag))
|
|
11700
|
+
tags.push(tag);
|
|
11701
|
+
}
|
|
11702
|
+
return { ok: true, tags };
|
|
11703
|
+
}
|
|
11704
|
+
|
|
11609
11705
|
// ../../packages/shared/dist/lib/workflow-template.js
|
|
11610
11706
|
var PLACEHOLDER = /\{\{\s*([A-Za-z][A-Za-z0-9_]{0,39})\s*\}\}/g;
|
|
11611
11707
|
var WHOLE_PLACEHOLDER = /^\{\{\s*([A-Za-z][A-Za-z0-9_]{0,39})\s*\}\}$/;
|
|
@@ -11890,7 +11986,7 @@ function validateWorkflowTemplate(raw, options = {}) {
|
|
|
11890
11986
|
summary: summary2
|
|
11891
11987
|
});
|
|
11892
11988
|
if (!isRecord2(raw)) {
|
|
11893
|
-
err(errors, "", "invalid_template", "A template is a JSON object: { name, description?, parameters, steps }");
|
|
11989
|
+
err(errors, "", "invalid_template", "A template is a JSON object: { name, description?, tags?, parameters, steps }");
|
|
11894
11990
|
return fail();
|
|
11895
11991
|
}
|
|
11896
11992
|
let size;
|
|
@@ -11905,8 +12001,8 @@ function validateWorkflowTemplate(raw, options = {}) {
|
|
|
11905
12001
|
return fail();
|
|
11906
12002
|
}
|
|
11907
12003
|
for (const key of Object.keys(raw)) {
|
|
11908
|
-
if (!["name", "description", "parameters", "steps"].includes(key)) {
|
|
11909
|
-
err(errors, pointer2("", key), "unknown_field", `A template has no field "${key}"; its fields are name, description, parameters, steps`);
|
|
12004
|
+
if (!["name", "description", "tags", "parameters", "steps"].includes(key)) {
|
|
12005
|
+
err(errors, pointer2("", key), "unknown_field", `A template has no field "${key}"; its fields are name, description, tags, parameters, steps`);
|
|
11910
12006
|
}
|
|
11911
12007
|
}
|
|
11912
12008
|
if (typeof raw.name !== "string" || raw.name.trim().length === 0 || raw.name.length > 80) {
|
|
@@ -11915,6 +12011,22 @@ function validateWorkflowTemplate(raw, options = {}) {
|
|
|
11915
12011
|
if (raw.description !== void 0 && (typeof raw.description !== "string" || raw.description.length > 2e3)) {
|
|
11916
12012
|
err(errors, "/description", "invalid_description", "description is at most 2000 characters");
|
|
11917
12013
|
}
|
|
12014
|
+
let tags = [];
|
|
12015
|
+
if (raw.tags !== void 0) {
|
|
12016
|
+
const written = raw.tags;
|
|
12017
|
+
if (!Array.isArray(written) || written.some((tag) => typeof tag !== "string")) {
|
|
12018
|
+
err(errors, "/tags", "invalid_tags", "tags is a list of text tags");
|
|
12019
|
+
} else if (written.length > WORKFLOW_TEMPLATE_TAGS_MAX) {
|
|
12020
|
+
err(errors, "/tags", "too_many_tags", `A template has at most ${WORKFLOW_TEMPLATE_TAGS_MAX} tags`);
|
|
12021
|
+
} else {
|
|
12022
|
+
const normalized = normalizeWorkflowTemplateTags(written);
|
|
12023
|
+
if (normalized.ok) {
|
|
12024
|
+
tags = normalized.tags;
|
|
12025
|
+
} else {
|
|
12026
|
+
err(errors, pointer2("/tags", String(written.indexOf(normalized.invalid))), "invalid_tag", `"${normalized.invalid.slice(0, 40)}" is not a tag: use letters, digits and hyphens, at most ${WORKFLOW_TEMPLATE_TAG_MAX_LENGTH} characters`);
|
|
12027
|
+
}
|
|
12028
|
+
}
|
|
12029
|
+
}
|
|
11918
12030
|
if (raw.steps === void 0) {
|
|
11919
12031
|
err(errors, "/steps", "missing_steps", "steps is the workflow: one task step or one pattern");
|
|
11920
12032
|
}
|
|
@@ -11964,6 +12076,7 @@ function validateWorkflowTemplate(raw, options = {}) {
|
|
|
11964
12076
|
const template = {
|
|
11965
12077
|
name: raw.name.trim(),
|
|
11966
12078
|
...typeof raw.description === "string" ? { description: raw.description } : {},
|
|
12079
|
+
...tags.length > 0 ? { tags } : {},
|
|
11967
12080
|
parameters,
|
|
11968
12081
|
steps: JSON.parse(JSON.stringify(raw.steps))
|
|
11969
12082
|
};
|
|
@@ -12007,6 +12120,7 @@ var duration = (defaultHours) => ({
|
|
|
12007
12120
|
var code = {
|
|
12008
12121
|
name: "Code: spec, review loop, deploy",
|
|
12009
12122
|
description: "A spec, then an implementation reviewed and fixed until the review approves it (up to the rounds you set), then your approval, then a deploy.",
|
|
12123
|
+
tags: ["code", "review", "deploy"],
|
|
12010
12124
|
parameters: {
|
|
12011
12125
|
brief: {
|
|
12012
12126
|
type: "string",
|
|
@@ -12092,6 +12206,7 @@ var code = {
|
|
|
12092
12206
|
var content = {
|
|
12093
12207
|
name: "Content: articles, then an edit",
|
|
12094
12208
|
description: "One article per topic you list, written in parallel, then an edit that brings them to one voice and standard.",
|
|
12209
|
+
tags: ["content", "writing", "editing"],
|
|
12095
12210
|
parameters: {
|
|
12096
12211
|
articles: {
|
|
12097
12212
|
type: "list",
|
|
@@ -12143,6 +12258,7 @@ var content = {
|
|
|
12143
12258
|
var research = {
|
|
12144
12259
|
name: "Research: parallel sources, then synthesis",
|
|
12145
12260
|
description: "Papers, the web and data researched at once by separate workers, then a synthesis that answers the question from all three.",
|
|
12261
|
+
tags: ["research", "analysis"],
|
|
12146
12262
|
parameters: {
|
|
12147
12263
|
question: {
|
|
12148
12264
|
type: "string",
|
|
@@ -18245,80 +18361,209 @@ function bugReportMeTooWriteChange(reportId) {
|
|
|
18245
18361
|
return { action: "me-too", reportId: reportId.toLowerCase() };
|
|
18246
18362
|
}
|
|
18247
18363
|
|
|
18248
|
-
// ../../packages/shared/dist/schemas/
|
|
18364
|
+
// ../../packages/shared/dist/schemas/listing-submission.schemas.js
|
|
18249
18365
|
import { z as z102 } from "zod";
|
|
18366
|
+
var LISTING_SUBMISSION_KINDS = ["catalog", "hook"];
|
|
18367
|
+
var LISTING_SUBMISSION_STATUSES = ["pending", "approved", "rejected"];
|
|
18368
|
+
var LISTING_SUBMISSION_REJECTION_MAX_CHARS = 2e3;
|
|
18369
|
+
var LISTING_SUBMISSION_MAX_BYTES = 64 * 1024;
|
|
18370
|
+
var CatalogSubmissionEntrySchema = CatalogX402EndpointEntrySchema.omit({
|
|
18371
|
+
trust: true,
|
|
18372
|
+
status: true,
|
|
18373
|
+
addedAt: true
|
|
18374
|
+
}).strict();
|
|
18375
|
+
var HookSubmissionManifestSchema = z102.string().min(2).max(LISTING_SUBMISSION_MAX_BYTES);
|
|
18376
|
+
var SubmitCatalogEntryInputSchema = z102.object({
|
|
18377
|
+
chainId: z102.number().int().positive().optional(),
|
|
18378
|
+
entry: CatalogSubmissionEntrySchema
|
|
18379
|
+
}).extend(WalletWriteProofSchema.shape);
|
|
18380
|
+
var SubmitHookListingInputSchema = z102.object({
|
|
18381
|
+
chainId: z102.number().int().positive().optional(),
|
|
18382
|
+
manifest: HookSubmissionManifestSchema
|
|
18383
|
+
}).extend(WalletWriteProofSchema.shape);
|
|
18384
|
+
var ListingSubmissionCheckSchema = z102.object({
|
|
18385
|
+
name: z102.string(),
|
|
18386
|
+
outcome: z102.enum(["pass", "fail", "inconclusive"]),
|
|
18387
|
+
detail: z102.string().nullable()
|
|
18388
|
+
});
|
|
18389
|
+
var ListingSubmissionSchema = z102.object({
|
|
18390
|
+
id: z102.string().uuid(),
|
|
18391
|
+
kind: z102.enum(LISTING_SUBMISSION_KINDS),
|
|
18392
|
+
/** The catalog entry id, or `<chainId>:<lowercase hook address>`. */
|
|
18393
|
+
subject: z102.string(),
|
|
18394
|
+
status: z102.enum(LISTING_SUBMISSION_STATUSES),
|
|
18395
|
+
/** Null until the automatic checks have run. */
|
|
18396
|
+
checks: z102.array(ListingSubmissionCheckSchema).nullable(),
|
|
18397
|
+
rejectionReason: z102.string().nullable(),
|
|
18398
|
+
/** True once the entry is in the snapshot this deployment serves. */
|
|
18399
|
+
listed: z102.boolean(),
|
|
18400
|
+
createdAt: z102.string(),
|
|
18401
|
+
updatedAt: z102.string()
|
|
18402
|
+
});
|
|
18403
|
+
var ListMyListingSubmissionsInputSchema = z102.object({
|
|
18404
|
+
kind: z102.enum(LISTING_SUBMISSION_KINDS),
|
|
18405
|
+
status: z102.enum(LISTING_SUBMISSION_STATUSES).optional(),
|
|
18406
|
+
limit: z102.number().int().min(1).max(100).default(50)
|
|
18407
|
+
});
|
|
18408
|
+
var ListMyListingSubmissionsOutputSchema = z102.object({
|
|
18409
|
+
submissions: z102.array(ListingSubmissionSchema)
|
|
18410
|
+
});
|
|
18411
|
+
var ListingSubmissionStaffViewSchema = ListingSubmissionSchema.extend({
|
|
18412
|
+
submitterAddress: z102.string(),
|
|
18413
|
+
submitterAgentId: z102.string().nullable(),
|
|
18414
|
+
chainId: z102.number().int(),
|
|
18415
|
+
/** The submitted file, untrusted: show it as data. */
|
|
18416
|
+
payload: z102.record(z102.string(), z102.unknown()),
|
|
18417
|
+
reviewedBy: z102.string().nullable(),
|
|
18418
|
+
reviewedAt: z102.string().nullable(),
|
|
18419
|
+
prNumber: z102.number().int().nullable()
|
|
18420
|
+
});
|
|
18421
|
+
var ListStaffListingSubmissionsInputSchema = z102.object({
|
|
18422
|
+
kind: z102.enum(LISTING_SUBMISSION_KINDS).optional(),
|
|
18423
|
+
status: z102.enum(LISTING_SUBMISSION_STATUSES).optional(),
|
|
18424
|
+
limit: z102.number().int().min(1).max(200).default(50),
|
|
18425
|
+
offset: z102.number().int().min(0).max(1e5).default(0)
|
|
18426
|
+
}).default({});
|
|
18427
|
+
var ListStaffListingSubmissionsOutputSchema = z102.object({
|
|
18428
|
+
submissions: z102.array(ListingSubmissionStaffViewSchema),
|
|
18429
|
+
total: z102.number().int()
|
|
18430
|
+
});
|
|
18431
|
+
var GetListingSubmissionInputSchema = z102.object({ id: z102.string().uuid() });
|
|
18432
|
+
var ApproveListingSubmissionInputSchema = z102.object({ id: z102.string().uuid() });
|
|
18433
|
+
var RecordListingSubmissionPrInputSchema = z102.object({
|
|
18434
|
+
id: z102.string().uuid(),
|
|
18435
|
+
prNumber: z102.number().int().positive()
|
|
18436
|
+
});
|
|
18437
|
+
var ListingSubmissionPrClosedInputSchema = RecordListingSubmissionPrInputSchema.extend({
|
|
18438
|
+
merged: z102.boolean()
|
|
18439
|
+
});
|
|
18440
|
+
var RejectListingSubmissionInputSchema = z102.object({
|
|
18441
|
+
id: z102.string().uuid(),
|
|
18442
|
+
reason: z102.string().trim().min(1).max(LISTING_SUBMISSION_REJECTION_MAX_CHARS)
|
|
18443
|
+
});
|
|
18444
|
+
var HIDDEN_CHARACTERS = (
|
|
18445
|
+
// eslint-disable-next-line no-control-regex
|
|
18446
|
+
/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F\u00AD\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u2069\uFEFF]/
|
|
18447
|
+
);
|
|
18448
|
+
function findHiddenCharacters(value, path3 = "$") {
|
|
18449
|
+
if (typeof value === "string")
|
|
18450
|
+
return HIDDEN_CHARACTERS.test(value) ? path3 : null;
|
|
18451
|
+
if (Array.isArray(value)) {
|
|
18452
|
+
for (let i = 0; i < value.length; i++) {
|
|
18453
|
+
const found = findHiddenCharacters(value[i], `${path3}[${i}]`);
|
|
18454
|
+
if (found)
|
|
18455
|
+
return found;
|
|
18456
|
+
}
|
|
18457
|
+
return null;
|
|
18458
|
+
}
|
|
18459
|
+
if (value && typeof value === "object") {
|
|
18460
|
+
for (const [key, child] of Object.entries(value)) {
|
|
18461
|
+
if (HIDDEN_CHARACTERS.test(key))
|
|
18462
|
+
return `${path3}.${key}`;
|
|
18463
|
+
const found = findHiddenCharacters(child, `${path3}.${key}`);
|
|
18464
|
+
if (found)
|
|
18465
|
+
return found;
|
|
18466
|
+
}
|
|
18467
|
+
}
|
|
18468
|
+
return null;
|
|
18469
|
+
}
|
|
18470
|
+
|
|
18471
|
+
// ../../packages/shared/dist/lib/catalog-probe.js
|
|
18472
|
+
var CATALOG_PROBE_MAX_BODY_CHARS = 64 * 1024;
|
|
18473
|
+
|
|
18474
|
+
// ../../packages/shared/dist/lib/listing-submission-write.js
|
|
18475
|
+
import { keccak256 as keccak2563, stringToBytes as stringToBytes2 } from "viem";
|
|
18476
|
+
function listingSubmissionContentHash(payload) {
|
|
18477
|
+
return keccak2563(stringToBytes2(canonicalSubmissionReviewValue(payload)));
|
|
18478
|
+
}
|
|
18479
|
+
function hookListingSubject(manifest) {
|
|
18480
|
+
const deployments = manifest.deployments;
|
|
18481
|
+
if (!Array.isArray(deployments) || deployments.length !== 1)
|
|
18482
|
+
return null;
|
|
18483
|
+
const deployment = deployments[0];
|
|
18484
|
+
if (!deployment || !Number.isSafeInteger(deployment.chainId) || typeof deployment.hook !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(deployment.hook)) {
|
|
18485
|
+
return null;
|
|
18486
|
+
}
|
|
18487
|
+
return `${deployment.chainId}:${deployment.hook.toLowerCase()}`;
|
|
18488
|
+
}
|
|
18489
|
+
function listingSubmissionWriteChange(kind, subject, payload) {
|
|
18490
|
+
return { action: "submit", kind, subject, contentHash: listingSubmissionContentHash(payload) };
|
|
18491
|
+
}
|
|
18492
|
+
|
|
18493
|
+
// ../../packages/shared/dist/schemas/user-skill-agent.schemas.js
|
|
18494
|
+
import { z as z103 } from "zod";
|
|
18250
18495
|
var AGENT_SKILL_REQUEST_BODY_LIMIT_BYTES = 1048576;
|
|
18251
18496
|
var agentSkillWriteBase = {
|
|
18252
18497
|
/** The owner's swarm wallet that signs; the backend resolves the owner from it. */
|
|
18253
18498
|
walletAddress: EthAddressSchema,
|
|
18254
18499
|
/** The hosted agent the write is made as; it must be one of that owner's live agents. */
|
|
18255
|
-
agentId:
|
|
18256
|
-
skillId:
|
|
18500
|
+
agentId: z103.string().uuid(),
|
|
18501
|
+
skillId: z103.string().uuid(),
|
|
18257
18502
|
/** One logical write: a resend with the same key and input returns the first result. */
|
|
18258
|
-
requestKey:
|
|
18503
|
+
requestKey: z103.string().uuid()
|
|
18259
18504
|
};
|
|
18260
|
-
var AgentUserSkillBundleWriteSchema =
|
|
18505
|
+
var AgentUserSkillBundleWriteSchema = z103.object({
|
|
18261
18506
|
...agentSkillWriteBase,
|
|
18262
18507
|
bundle: UserSkillDraftBundleSchema,
|
|
18263
|
-
note:
|
|
18508
|
+
note: z103.string().trim().max(500).default("")
|
|
18264
18509
|
});
|
|
18265
|
-
var AgentUserSkillArchiveWriteSchema =
|
|
18510
|
+
var AgentUserSkillArchiveWriteSchema = z103.object({
|
|
18266
18511
|
...agentSkillWriteBase,
|
|
18267
|
-
removeAssignments:
|
|
18512
|
+
removeAssignments: z103.boolean().default(false)
|
|
18268
18513
|
});
|
|
18269
18514
|
var AgentUserSkillCreateInputSchema = AgentUserSkillBundleWriteSchema.extend(WalletWriteProofSchema.shape).strict();
|
|
18270
18515
|
var AgentUserSkillArchiveInputSchema = AgentUserSkillArchiveWriteSchema.extend(WalletWriteProofSchema.shape).strict();
|
|
18271
|
-
var AgentUserSkillVersionResultSchema =
|
|
18272
|
-
skillId:
|
|
18273
|
-
version:
|
|
18274
|
-
revision:
|
|
18275
|
-
});
|
|
18276
|
-
var AgentUserSkillArchiveResultSchema =
|
|
18277
|
-
skillId:
|
|
18278
|
-
archived:
|
|
18279
|
-
revision:
|
|
18280
|
-
});
|
|
18281
|
-
var hostedAgentId =
|
|
18282
|
-
var HostedSkillCreateInputSchema =
|
|
18516
|
+
var AgentUserSkillVersionResultSchema = z103.object({
|
|
18517
|
+
skillId: z103.string().uuid(),
|
|
18518
|
+
version: z103.number().int().positive(),
|
|
18519
|
+
revision: z103.number().int().nonnegative()
|
|
18520
|
+
});
|
|
18521
|
+
var AgentUserSkillArchiveResultSchema = z103.object({
|
|
18522
|
+
skillId: z103.string().uuid(),
|
|
18523
|
+
archived: z103.literal(true),
|
|
18524
|
+
revision: z103.number().int().nonnegative()
|
|
18525
|
+
});
|
|
18526
|
+
var hostedAgentId = z103.string().uuid().optional();
|
|
18527
|
+
var HostedSkillCreateInputSchema = z103.object({
|
|
18283
18528
|
agentId: hostedAgentId,
|
|
18284
|
-
skillId:
|
|
18529
|
+
skillId: z103.string().uuid().optional(),
|
|
18285
18530
|
bundle: UserSkillDraftBundleSchema,
|
|
18286
|
-
note:
|
|
18531
|
+
note: z103.string().trim().max(500).optional()
|
|
18287
18532
|
}).strict();
|
|
18288
|
-
var HostedSkillVersionInputSchema =
|
|
18533
|
+
var HostedSkillVersionInputSchema = z103.object({
|
|
18289
18534
|
agentId: hostedAgentId,
|
|
18290
|
-
skillId:
|
|
18535
|
+
skillId: z103.string().uuid(),
|
|
18291
18536
|
bundle: UserSkillDraftBundleSchema,
|
|
18292
|
-
note:
|
|
18537
|
+
note: z103.string().trim().max(500).optional()
|
|
18293
18538
|
}).strict();
|
|
18294
|
-
var HostedSkillArchiveInputSchema =
|
|
18539
|
+
var HostedSkillArchiveInputSchema = z103.object({
|
|
18295
18540
|
agentId: hostedAgentId,
|
|
18296
|
-
skillId:
|
|
18297
|
-
removeAssignments:
|
|
18541
|
+
skillId: z103.string().uuid(),
|
|
18542
|
+
removeAssignments: z103.boolean().optional()
|
|
18298
18543
|
}).strict();
|
|
18299
18544
|
var HostedSkillImportInputSchema = UserSkillImportPreviewInputSchema.extend({
|
|
18300
18545
|
agentId: hostedAgentId,
|
|
18301
|
-
skillId:
|
|
18302
|
-
confirmExclusions:
|
|
18303
|
-
note:
|
|
18546
|
+
skillId: z103.string().uuid().optional(),
|
|
18547
|
+
confirmExclusions: z103.boolean().optional(),
|
|
18548
|
+
note: z103.string().trim().max(500).optional()
|
|
18304
18549
|
}).strict();
|
|
18305
|
-
var HostedSkillUpdateInputSchema =
|
|
18550
|
+
var HostedSkillUpdateInputSchema = z103.object({
|
|
18306
18551
|
agentId: hostedAgentId,
|
|
18307
|
-
skillId:
|
|
18308
|
-
confirmExclusions:
|
|
18309
|
-
note:
|
|
18552
|
+
skillId: z103.string().uuid(),
|
|
18553
|
+
confirmExclusions: z103.boolean().optional(),
|
|
18554
|
+
note: z103.string().trim().max(500).optional()
|
|
18310
18555
|
}).strict();
|
|
18311
|
-
var HostedSkillListInputSchema =
|
|
18312
|
-
var HostedSkillShowInputSchema =
|
|
18556
|
+
var HostedSkillListInputSchema = z103.object({ agentId: hostedAgentId }).strict();
|
|
18557
|
+
var HostedSkillShowInputSchema = z103.object({
|
|
18313
18558
|
agentId: hostedAgentId,
|
|
18314
|
-
skillId:
|
|
18315
|
-
version:
|
|
18316
|
-
path:
|
|
18317
|
-
offset:
|
|
18559
|
+
skillId: z103.string().uuid(),
|
|
18560
|
+
version: z103.number().int().positive().optional(),
|
|
18561
|
+
path: z103.string().min(1).max(240).optional(),
|
|
18562
|
+
offset: z103.number().int().nonnegative().optional()
|
|
18318
18563
|
}).strict();
|
|
18319
|
-
var HostedSkillSourceSummarySchema =
|
|
18320
|
-
|
|
18321
|
-
|
|
18564
|
+
var HostedSkillSourceSummarySchema = z103.discriminatedUnion("kind", [
|
|
18565
|
+
z103.object({ kind: z103.literal("upload") }),
|
|
18566
|
+
z103.object({ kind: z103.literal("agent"), agentId: z103.string().uuid() }),
|
|
18322
18567
|
UserSkillGithubSourceSchema.pick({
|
|
18323
18568
|
kind: true,
|
|
18324
18569
|
repo: true,
|
|
@@ -18328,38 +18573,38 @@ var HostedSkillSourceSummarySchema = z102.discriminatedUnion("kind", [
|
|
|
18328
18573
|
license: true
|
|
18329
18574
|
})
|
|
18330
18575
|
]);
|
|
18331
|
-
var HostedSkillShareInputSchema =
|
|
18576
|
+
var HostedSkillShareInputSchema = z103.object({
|
|
18332
18577
|
agentId: hostedAgentId,
|
|
18333
|
-
skillId:
|
|
18334
|
-
version:
|
|
18578
|
+
skillId: z103.string().uuid(),
|
|
18579
|
+
version: z103.number().int().positive().optional(),
|
|
18335
18580
|
/** The receiving agent: this agent's own ID, or another live agent of the same owner. */
|
|
18336
|
-
toAgentId:
|
|
18581
|
+
toAgentId: z103.string().uuid()
|
|
18337
18582
|
}).strict();
|
|
18338
|
-
var AgentUserSkillShareWriteSchema =
|
|
18339
|
-
agentId:
|
|
18340
|
-
skillId:
|
|
18341
|
-
version:
|
|
18342
|
-
toAgentId:
|
|
18343
|
-
requestKey:
|
|
18344
|
-
});
|
|
18345
|
-
var AgentUserSkillShareResultSchema =
|
|
18346
|
-
skillId:
|
|
18347
|
-
version:
|
|
18348
|
-
toAgentId:
|
|
18349
|
-
status:
|
|
18350
|
-
requestId:
|
|
18583
|
+
var AgentUserSkillShareWriteSchema = z103.object({
|
|
18584
|
+
agentId: z103.string().uuid(),
|
|
18585
|
+
skillId: z103.string().uuid(),
|
|
18586
|
+
version: z103.number().int().positive().optional(),
|
|
18587
|
+
toAgentId: z103.string().uuid(),
|
|
18588
|
+
requestKey: z103.string().uuid()
|
|
18589
|
+
});
|
|
18590
|
+
var AgentUserSkillShareResultSchema = z103.object({
|
|
18591
|
+
skillId: z103.string().uuid(),
|
|
18592
|
+
version: z103.number().int().positive(),
|
|
18593
|
+
toAgentId: z103.string().uuid(),
|
|
18594
|
+
status: z103.enum(["assigned", "pending"]),
|
|
18595
|
+
requestId: z103.string().uuid().nullable(),
|
|
18351
18596
|
/**
|
|
18352
18597
|
* Issue #4461: true when the version holds text from outside the owner (imported from GitHub, or
|
|
18353
18598
|
* saved in a turn that handled untrusted content), so even a share with the agent itself or a
|
|
18354
18599
|
* share in free mode waits for the owner's approval.
|
|
18355
18600
|
*/
|
|
18356
|
-
untrustedContent:
|
|
18601
|
+
untrustedContent: z103.literal(true).optional()
|
|
18357
18602
|
});
|
|
18358
18603
|
|
|
18359
18604
|
// ../../packages/shared/dist/lib/user-skill-write.js
|
|
18360
|
-
import { keccak256 as
|
|
18605
|
+
import { keccak256 as keccak2564, stringToBytes as stringToBytes3 } from "viem";
|
|
18361
18606
|
function contentHash2(value) {
|
|
18362
|
-
return
|
|
18607
|
+
return keccak2564(stringToBytes3(canonicalSubmissionReviewValue(value)));
|
|
18363
18608
|
}
|
|
18364
18609
|
function bundleChange(action, input2) {
|
|
18365
18610
|
const parsed = AgentUserSkillBundleWriteSchema.parse(input2);
|
|
@@ -19044,7 +19289,7 @@ function piCodingAgentTools(options) {
|
|
|
19044
19289
|
}
|
|
19045
19290
|
|
|
19046
19291
|
// ../../packages/shared/dist/task-templates/templates.js
|
|
19047
|
-
import { z as
|
|
19292
|
+
import { z as z104 } from "zod";
|
|
19048
19293
|
|
|
19049
19294
|
// ../../packages/shared/dist/task-templates/catalogue.js
|
|
19050
19295
|
var taskTemplateCatalogue = [
|
|
@@ -20376,38 +20621,38 @@ var BRIEF_HEADINGS = [
|
|
|
20376
20621
|
"Boundaries",
|
|
20377
20622
|
"How selection works"
|
|
20378
20623
|
];
|
|
20379
|
-
var tokenSchema =
|
|
20380
|
-
key:
|
|
20381
|
-
label:
|
|
20382
|
-
placeholder:
|
|
20383
|
-
defaultValue:
|
|
20384
|
-
required:
|
|
20624
|
+
var tokenSchema = z104.object({
|
|
20625
|
+
key: z104.string().regex(/^[a-z][a-zA-Z0-9]*$/),
|
|
20626
|
+
label: z104.string().min(1),
|
|
20627
|
+
placeholder: z104.string().min(1),
|
|
20628
|
+
defaultValue: z104.string().min(1).optional(),
|
|
20629
|
+
required: z104.boolean()
|
|
20385
20630
|
}).strict();
|
|
20386
|
-
var readinessItemSchema =
|
|
20387
|
-
key:
|
|
20388
|
-
label:
|
|
20389
|
-
help:
|
|
20390
|
-
input:
|
|
20391
|
-
placeholder:
|
|
20392
|
-
defaultValue:
|
|
20393
|
-
publicAccess:
|
|
20394
|
-
required:
|
|
20631
|
+
var readinessItemSchema = z104.object({
|
|
20632
|
+
key: z104.string().regex(/^[a-z][a-zA-Z0-9]*$/),
|
|
20633
|
+
label: z104.string().min(1),
|
|
20634
|
+
help: z104.string().min(1),
|
|
20635
|
+
input: z104.enum(["shortText", "longText", "url"]),
|
|
20636
|
+
placeholder: z104.string().min(1),
|
|
20637
|
+
defaultValue: z104.string().min(1).optional(),
|
|
20638
|
+
publicAccess: z104.enum(["required", "notApplicable"]),
|
|
20639
|
+
required: z104.boolean()
|
|
20395
20640
|
}).strict().superRefine((item, ctx) => {
|
|
20396
20641
|
if (item.publicAccess === "required" && item.input !== "url") {
|
|
20397
20642
|
ctx.addIssue({
|
|
20398
|
-
code:
|
|
20643
|
+
code: z104.ZodIssueCode.custom,
|
|
20399
20644
|
message: "Public-access readiness items must use a URL input.",
|
|
20400
20645
|
path: ["input"]
|
|
20401
20646
|
});
|
|
20402
20647
|
}
|
|
20403
20648
|
});
|
|
20404
|
-
var briefSectionSchemas = BRIEF_HEADINGS.map((heading) =>
|
|
20405
|
-
var baseTemplateSchema =
|
|
20406
|
-
id:
|
|
20407
|
-
label:
|
|
20408
|
-
shortDescription:
|
|
20409
|
-
titleTemplate:
|
|
20410
|
-
icon:
|
|
20649
|
+
var briefSectionSchemas = BRIEF_HEADINGS.map((heading) => z104.object({ heading: z104.literal(heading), body: z104.string().min(1) }).strict());
|
|
20650
|
+
var baseTemplateSchema = z104.object({
|
|
20651
|
+
id: z104.enum(TASK_TEMPLATE_IDS),
|
|
20652
|
+
label: z104.string().min(1),
|
|
20653
|
+
shortDescription: z104.string().min(1),
|
|
20654
|
+
titleTemplate: z104.string().min(1),
|
|
20655
|
+
icon: z104.enum([
|
|
20411
20656
|
"activity",
|
|
20412
20657
|
"bug",
|
|
20413
20658
|
"chart",
|
|
@@ -20425,37 +20670,37 @@ var baseTemplateSchema = z103.object({
|
|
|
20425
20670
|
"sparkles",
|
|
20426
20671
|
"transfer"
|
|
20427
20672
|
]),
|
|
20428
|
-
motif:
|
|
20429
|
-
durationHours:
|
|
20430
|
-
tags:
|
|
20431
|
-
bestFor:
|
|
20432
|
-
details:
|
|
20433
|
-
tokens:
|
|
20434
|
-
readiness:
|
|
20435
|
-
brief:
|
|
20673
|
+
motif: z104.enum(["grid", "rays", "rings", "signal", "steps"]),
|
|
20674
|
+
durationHours: z104.number().int().min(24).max(720),
|
|
20675
|
+
tags: z104.array(z104.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)).min(3).max(5).refine((tags) => new Set(tags).size === tags.length, "Template tags must be unique."),
|
|
20676
|
+
bestFor: z104.tuple([z104.string().min(1), z104.string().min(1), z104.string().min(1)]),
|
|
20677
|
+
details: z104.object({ includes: z104.string().min(1), success: z104.string().min(1) }).strict(),
|
|
20678
|
+
tokens: z104.array(tokenSchema).min(2).max(3),
|
|
20679
|
+
readiness: z104.array(readinessItemSchema).min(1).max(3),
|
|
20680
|
+
brief: z104.tuple(briefSectionSchemas).readonly()
|
|
20436
20681
|
}).strict();
|
|
20437
|
-
var catalogueSchema =
|
|
20438
|
-
baseTemplateSchema.extend({ mode:
|
|
20682
|
+
var catalogueSchema = z104.array(z104.discriminatedUnion("mode", [
|
|
20683
|
+
baseTemplateSchema.extend({ mode: z104.literal("bounty") }),
|
|
20439
20684
|
baseTemplateSchema.extend({
|
|
20440
|
-
mode:
|
|
20441
|
-
modeDefaults:
|
|
20685
|
+
mode: z104.literal("claim"),
|
|
20686
|
+
modeDefaults: z104.object({ stakeRequired: z104.literal(false), stakeBps: z104.literal("0") }).strict()
|
|
20442
20687
|
}),
|
|
20443
20688
|
baseTemplateSchema.extend({
|
|
20444
|
-
mode:
|
|
20445
|
-
modeDefaults:
|
|
20689
|
+
mode: z104.literal("pitch"),
|
|
20690
|
+
modeDefaults: z104.object({ pitchDeadline: z104.string().regex(/^[1-9]\d*$/) }).strict()
|
|
20446
20691
|
}),
|
|
20447
20692
|
baseTemplateSchema.extend({
|
|
20448
|
-
mode:
|
|
20449
|
-
modeDefaults:
|
|
20450
|
-
metricDescription:
|
|
20451
|
-
metricTarget:
|
|
20693
|
+
mode: z104.literal("benchmark"),
|
|
20694
|
+
modeDefaults: z104.object({
|
|
20695
|
+
metricDescription: z104.string().min(1),
|
|
20696
|
+
metricTarget: z104.string().min(1)
|
|
20452
20697
|
}).strict()
|
|
20453
20698
|
}),
|
|
20454
20699
|
baseTemplateSchema.extend({
|
|
20455
|
-
mode:
|
|
20456
|
-
modeDefaults:
|
|
20457
|
-
auctionType:
|
|
20458
|
-
bidDeadline:
|
|
20700
|
+
mode: z104.literal("auction"),
|
|
20701
|
+
modeDefaults: z104.object({
|
|
20702
|
+
auctionType: z104.enum(["english", "reverse_english"]),
|
|
20703
|
+
bidDeadline: z104.string().regex(/^[1-9]\d*$/)
|
|
20459
20704
|
}).strict()
|
|
20460
20705
|
})
|
|
20461
20706
|
]));
|
|
@@ -20732,8 +20977,11 @@ export {
|
|
|
20732
20977
|
WORKFLOW_STEP_LIMIT_MIN,
|
|
20733
20978
|
WORKFLOW_STEP_LIMIT_MAX,
|
|
20734
20979
|
WORKFLOW_TEMPLATE_PARAMETERS_MAX,
|
|
20980
|
+
WORKFLOW_TEMPLATE_SEARCH_MAX_LENGTH,
|
|
20981
|
+
WORKFLOW_TEMPLATE_SEARCH_TAGS_MAX,
|
|
20735
20982
|
WORKFLOW_PRESET_NAMES,
|
|
20736
20983
|
OFFICIAL_WORKFLOW_TEMPLATE_ID,
|
|
20984
|
+
WORKFLOW_TEMPLATE_SEARCH_SORTS,
|
|
20737
20985
|
INITIAL_BRIEF_TURN_MESSAGE,
|
|
20738
20986
|
isInitialBriefTurnMessage,
|
|
20739
20987
|
BriefSessionViewSchema,
|
|
@@ -20741,6 +20989,7 @@ export {
|
|
|
20741
20989
|
getAgentName,
|
|
20742
20990
|
normalizeReferenceCode,
|
|
20743
20991
|
validateWorkflowDocument,
|
|
20992
|
+
normalizeWorkflowTemplateTags,
|
|
20744
20993
|
validateWorkflowTemplate,
|
|
20745
20994
|
dreamsToUsd,
|
|
20746
20995
|
formatDreams,
|
|
@@ -20827,6 +21076,12 @@ export {
|
|
|
20827
21076
|
bugReportCommentWriteChange,
|
|
20828
21077
|
bugReportVisibilityWriteChange,
|
|
20829
21078
|
bugReportMeTooWriteChange,
|
|
21079
|
+
LISTING_SUBMISSION_STATUSES,
|
|
21080
|
+
LISTING_SUBMISSION_MAX_BYTES,
|
|
21081
|
+
CatalogSubmissionEntrySchema,
|
|
21082
|
+
findHiddenCharacters,
|
|
21083
|
+
hookListingSubject,
|
|
21084
|
+
listingSubmissionWriteChange,
|
|
20830
21085
|
AGENT_SKILL_REQUEST_BODY_LIMIT_BYTES,
|
|
20831
21086
|
AgentUserSkillBundleWriteSchema,
|
|
20832
21087
|
AgentUserSkillArchiveWriteSchema,
|