@qawolf/api-contracts 0.59.0 → 0.63.0

package/dist/v1/runner/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/v1/runner/catalog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAqBhD,eAAO,MAAM,mBAAmB,GAAI,WAAW,SAAS,cAAc,EAAE,KAAK;IAC3E,cAAc,EAAE,cAAc,CAAC;IAC/B,SAAS,EAAE,WAAW,CAAC;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiBC,CAAC"}

package/dist/v1/runner/catalog.js

@@ -0,0 +1,34 @@
+import { makeEvaluateSnippetOnRunnerContract } from "./evaluateSnippet.js";
+import { makeGetRunnerContract } from "./get.js";
+import { makeHighlightSelectorOnRunnerContract } from "./highlightSelector.js";
+import { makeImportPackageOnRunnerContract } from "./importPackage.js";
+import { makeLaunchRunnerContract, makeTerminateRunnerContract, } from "./index.js";
+import { makeInspectOnRunnerContract } from "./inspect.js";
+import { makeInspectMobileOnRunnerContract } from "./inspectMobile.js";
+import { makeListRunnersContract } from "./list.js";
+import { makePerformActionOnRunnerContract } from "./performAction.js";
+import { makePerformActionsOnRunnerContract } from "./performActions.js";
+import { makePromoteSnapshotOnRunnerContract } from "./promoteSnapshot.js";
+import { makeReadRunnerJournalContract } from "./readJournal.js";
+import { makeRunFlowOnRunnerContract } from "./runFlow.js";
+import { makeStopRunOnRunnerContract } from "./stopRun.js";
+import { makeTakeScreenshotOnRunnerContract } from "./takeScreenshot.js";
+export const makeRunnerContracts = (ids) => ({
+    evaluateSnippet: makeEvaluateSnippetOnRunnerContract(ids),
+    get: makeGetRunnerContract(ids),
+    highlightSelector: makeHighlightSelectorOnRunnerContract(ids),
+    importPackage: makeImportPackageOnRunnerContract(ids),
+    inspect: makeInspectOnRunnerContract(ids),
+    inspectMobile: makeInspectMobileOnRunnerContract(ids),
+    launch: makeLaunchRunnerContract(ids),
+    list: makeListRunnersContract(ids),
+    performAction: makePerformActionOnRunnerContract(ids),
+    performActions: makePerformActionsOnRunnerContract(ids),
+    promoteSnapshot: makePromoteSnapshotOnRunnerContract(ids),
+    readJournal: makeReadRunnerJournalContract(ids),
+    runFlow: makeRunFlowOnRunnerContract(ids),
+    stopRun: makeStopRunOnRunnerContract(ids),
+    takeScreenshot: makeTakeScreenshotOnRunnerContract(ids),
+    terminate: makeTerminateRunnerContract(ids),
+});
+//# sourceMappingURL=catalog.js.map

package/dist/v1/runner/catalog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.js","sourceRoot":"","sources":["../../../src/v1/runner/catalog.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mCAAmC,EAAE,MAAM,sBAAsB,CAAC;AAC3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AACjD,OAAO,EAAE,qCAAqC,EAAE,MAAM,wBAAwB,CAAC;AAC/E,OAAO,EAAE,iCAAiC,EAAE,MAAM,oBAAoB,CAAC;AACvE,OAAO,EACL,wBAAwB,EACxB,2BAA2B,GAC5B,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,2BAA2B,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,EAAE,iCAAiC,EAAE,MAAM,oBAAoB,CAAC;AACvE,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAE,iCAAiC,EAAE,MAAM,oBAAoB,CAAC;AACvE,OAAO,EAAE,kCAAkC,EAAE,MAAM,qBAAqB,CAAC;AACzE,OAAO,EAAE,mCAAmC,EAAE,MAAM,sBAAsB,CAAC;AAC3E,OAAO,EAAE,6BAA6B,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,EAAE,2BAA2B,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,EAAE,2BAA2B,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,EAAE,kCAAkC,EAAE,MAAM,qBAAqB,CAAC;AAEzE,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAqC,GAGvE,EAAE,EAAE,CAAC,CAAC;IACL,eAAe,EAAE,mCAAmC,CAAC,GAAG,CAAC;IACzD,GAAG,EAAE,qBAAqB,CAAC,GAAG,CAAC;IAC/B,iBAAiB,EAAE,qCAAqC,CAAC,GAAG,CAAC;IAC7D,aAAa,EAAE,iCAAiC,CAAC,GAAG,CAAC;IACrD,OAAO,EAAE,2BAA2B,CAAC,GAAG,CAAC;IACzC,aAAa,EAAE,iCAAiC,CAAC,GAAG,CAAC;IACrD,MAAM,EAAE,wBAAwB,CAAC,GAAG,CAAC;IACrC,IAAI,EAAE,uBAAuB,CAAC,GAAG,CAAC;IAClC,aAAa,EAAE,iCAAiC,CAAC,GAAG,CAAC;IACrD,cAAc,EAAE,kCAAkC,CAAC,GAAG,CAAC;IACvD,eAAe,EAAE,mCAAmC,CAAC,GAAG,CAAC;IACzD,WAAW,EAAE,6BAA6B,CAAC,GAAG,CAAC;IAC/C,OAAO,EAAE,2BAA2B,CAAC,GAAG,CAAC;IACzC,OAAO,EAAE,2BAA2B,CAAC,GAAG,CAAC;IACzC,cAAc,EAAE,kCAAkC,CAAC,GAAG,CAAC;IACvD,SAAS,EAAE,2BAA2B,CAAC,GAAG,CAAC;CAC5C,CAAC,CAAC"}

package/dist/v1/runner/performActions.d.ts

@@ -0,0 +1,124 @@
+import { z } from "zod";
+import type { PublicIdSchema } from "../ids.js";
+export { type ActionStepResult, type FailedActionStep, type PerformedActionStep, outOfTimeFailureReason, unconfirmedFailureReason, } from "./performActionsSteps.js";
+export declare const makePerformActionsOnRunnerContract: <WorkspaceId extends PublicIdSchema>(ids: {
+    workspace: WorkspaceId;
+}) => {
+    readonly annotations: {
+        readonly destructiveHint: true;
+        readonly openWorldHint: true;
+        readonly readOnlyHint: false;
+    };
+    readonly description: "Perform a sequence of raw browser actions on an interactive runner in one request, one after another, and answer with what happened to each. A `success` means every action took effect. A `failure` names the first action that did not (`failedIndex`, `failureReason`), the last one that did (`lastCompletedIndex`), and whether actions were left unperformed (`stoppedEarly`); `results` has one entry per action reached, in order. Read `effect` on an entry before sending its action again: `performed` means the runner did it; `not-performed` means the runner answered that it did not take effect, though a `navigate` that timed out may still be loading; `unknown` means the runner stopped answering with the action in flight (`runner-unreachable`), or its screen went quiet mid-action (`action-unconfirmed`), and it may have taken effect — a click that submitted a form, say — so take a screenshot instead of repeating it. A sequence gets about a minute to start its actions; an action it did not reach in time is `out-of-time`, nothing after it was attempted, and the rest can go in a new request. Everything `runner.performAction` says about a runner that has never run anything, a mobile runner, and the `screen-needs-a-run`, `screen-not-ready`, `runner-has-no-screen` and `action-not-supported-on-mobile` reasons holds for each action here.";
+    readonly input: z.ZodObject<{
+        actions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            button: z.ZodLiteral<"left" | "right" | "wheel" | "back" | "forward">;
+            type: z.ZodLiteral<"click">;
+            x: z.ZodInt;
+            y: z.ZodInt;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"double_click">;
+            x: z.ZodInt;
+            y: z.ZodInt;
+        }, z.core.$strict>, z.ZodObject<{
+            scroll_x: z.ZodInt;
+            scroll_y: z.ZodInt;
+            type: z.ZodLiteral<"scroll">;
+            x: z.ZodInt;
+            y: z.ZodInt;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"move">;
+            x: z.ZodInt;
+            y: z.ZodInt;
+        }, z.core.$strict>, z.ZodObject<{
+            path: z.ZodArray<z.ZodObject<{
+                x: z.ZodInt;
+                y: z.ZodInt;
+            }, z.core.$strict>>;
+            type: z.ZodLiteral<"drag">;
+        }, z.core.$strict>, z.ZodObject<{
+            keys: z.ZodArray<z.ZodString>;
+            type: z.ZodLiteral<"keypress">;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"navigate">;
+            url: z.ZodURL;
+        }, z.core.$strict>, z.ZodObject<{
+            text: z.ZodString;
+            type: z.ZodLiteral<"type">;
+        }, z.core.$strict>], "type">>;
+        id: z.ZodString;
+        screenshotMode: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            final: "final";
+            each: "each";
+        }>>;
+        stopOnFailure: z.ZodOptional<z.ZodBoolean>;
+        workspaceId: z.ZodOptional<WorkspaceId>;
+    }, z.core.$strip>;
+    readonly kind: "write";
+    readonly name: "runner.performActions";
+    readonly output: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        imageJpegBase64: z.ZodOptional<z.ZodString>;
+        lastCompletedIndex: z.ZodInt;
+        outcome: z.ZodLiteral<"success">;
+        results: z.ZodArray<z.ZodObject<{
+            effect: z.ZodLiteral<"performed">;
+            imageJpegBase64: z.ZodOptional<z.ZodString>;
+            index: z.ZodInt;
+            outcome: z.ZodLiteral<"success">;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        errorMessage: z.ZodOptional<z.ZodString>;
+        failedIndex: z.ZodInt;
+        failureReason: z.ZodEnum<{
+            "runner-unreachable": "runner-unreachable";
+            "screen-needs-a-run": "screen-needs-a-run";
+            "screen-not-ready": "screen-not-ready";
+            "action-failed": "action-failed";
+            "runner-has-no-screen": "runner-has-no-screen";
+            "action-not-supported-on-mobile": "action-not-supported-on-mobile";
+            "out-of-time": "out-of-time";
+            "action-unconfirmed": "action-unconfirmed";
+        }>;
+        imageJpegBase64: z.ZodOptional<z.ZodString>;
+        lastCompletedIndex: z.ZodOptional<z.ZodInt>;
+        outcome: z.ZodLiteral<"failure">;
+        results: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            effect: z.ZodLiteral<"performed">;
+            imageJpegBase64: z.ZodOptional<z.ZodString>;
+            index: z.ZodInt;
+            outcome: z.ZodLiteral<"success">;
+        }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            effect: z.ZodLiteral<"not-performed">;
+            errorMessage: z.ZodString;
+            failureReason: z.ZodLiteral<"action-failed">;
+            imageJpegBase64: z.ZodOptional<z.ZodString>;
+            index: z.ZodInt;
+            outcome: z.ZodLiteral<"failure">;
+        }, z.core.$strip>, z.ZodObject<{
+            effect: z.ZodLiteral<"unknown">;
+            failureReason: z.ZodLiteral<"runner-unreachable">;
+            index: z.ZodInt;
+            outcome: z.ZodLiteral<"failure">;
+        }, z.core.$strip>, z.ZodObject<{
+            effect: z.ZodLiteral<"unknown">;
+            errorMessage: z.ZodString;
+            failureReason: z.ZodLiteral<"action-unconfirmed">;
+            index: z.ZodInt;
+            outcome: z.ZodLiteral<"failure">;
+        }, z.core.$strip>, z.ZodObject<{
+            effect: z.ZodLiteral<"not-performed">;
+            failureReason: z.ZodEnum<{
+                "screen-needs-a-run": "screen-needs-a-run";
+                "screen-not-ready": "screen-not-ready";
+                "runner-has-no-screen": "runner-has-no-screen";
+                "action-not-supported-on-mobile": "action-not-supported-on-mobile";
+                "out-of-time": "out-of-time";
+            }>;
+            index: z.ZodInt;
+            outcome: z.ZodLiteral<"failure">;
+        }, z.core.$strip>], "failureReason">], "outcome">>;
+        stoppedEarly: z.ZodBoolean;
+    }, z.core.$strip>], "outcome">;
+};
+//# sourceMappingURL=performActions.d.ts.map

package/dist/v1/runner/performActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"performActions.d.ts","sourceRoot":"","sources":["../../../src/v1/runner/performActions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAchD,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,0BAA0B,CAAC;AAalC,eAAO,MAAM,kCAAkC,GAC7C,WAAW,SAAS,cAAc,EAClC,KAAK;IACL,SAAS,EAAE,WAAW,CAAC;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2FA,CAAC"}

package/dist/v1/runner/performActions.js

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import { maxActionsPerRequest, screenshotModes } from "./actionSequence.js";
+import { browserActionSchema } from "./browserAction.js";
+import { runnerIdSchema, runnerWorkspaceIdDescription } from "./identity.js";
+import { maxActionErrorMessageLength } from "./performAction.js";
+import { actionIndexSchema, performedStepSchema, sequenceFailureReasons, stepResultSchema, } from "./performActionsSteps.js";
+import { screenshotImageSchema } from "./screen.js";
+export { outOfTimeFailureReason, unconfirmedFailureReason, } from "./performActionsSteps.js";
+const actionsDescription = `The actions to perform, in order, each exactly what \`runner.performAction\` takes: coordinates are whole pixels on the runner's virtual desktop, in the same space as \`runner.takeScreenshot\`, and the shapes follow the computer-use vocabulary. At most ${maxActionsPerRequest} per request. For when the next several steps are already known — click a field, type into it, press Enter — and one look at the screen at the end is enough. They run back to back on the runner, with no pause between them: put in one request only steps whose targets are all on the screen you last saw and are not moved by the steps before them, and when a step changes the page — a submit, a navigation, opening a menu — make it the last one and read the frame.`;
+const screenshotModeDescription = "`final`, the default, answers with one screenshot in `imageJpegBase64`: the screen after the last action, or, after a stop, as it stands. `each` puts a screenshot after every action on its entry in `results`, for when each step must be checked; every frame is a full image, so keep such sequences short. `none` sends no screenshot.";
+const stopOnFailureDescription = "`true`, the default, leaves the remaining actions unperformed once one fails. `false` carries on past an action that reached the runner and did not take effect (`action-failed`, `action-not-supported-on-mobile`), so use it only for actions that do not depend on each other: a `type` after a `click` that failed goes to whatever has focus. A runner that cannot be reached, a screen that cannot serve, or running out of time ends the sequence either way.";
+const finalImageDescription = "Present with `screenshotMode: final` when the runner still answered: the screen after the last action performed, or, after a stop, as it stands.";
+export const makePerformActionsOnRunnerContract = (ids) => {
+    const input = z.object({
+        actions: z
+            .array(browserActionSchema)
+            .min(1)
+            .max(maxActionsPerRequest)
+            .describe(actionsDescription),
+        id: runnerIdSchema.describe("Id of the runner to act on."),
+        screenshotMode: z
+            .enum(screenshotModes)
+            .optional()
+            .describe(screenshotModeDescription),
+        stopOnFailure: z.boolean().optional().describe(stopOnFailureDescription),
+        workspaceId: ids.workspace
+            .optional()
+            .describe(runnerWorkspaceIdDescription),
+    });
+    const output = z.discriminatedUnion("outcome", [
+        z.object({
+            imageJpegBase64: screenshotImageSchema
+                .optional()
+                .describe(finalImageDescription),
+            lastCompletedIndex: actionIndexSchema.describe("Index of the last action that took effect: here, the last one sent."),
+            outcome: z.literal("success"),
+            results: z
+                .array(performedStepSchema)
+                .min(1)
+                .max(maxActionsPerRequest)
+                .describe("One entry per action, in order."),
+        }),
+        z.object({
+            errorMessage: z
+                .string()
+                .max(maxActionErrorMessageLength)
+                .optional()
+                .describe("What stopped the first failed action, when its reason is `action-failed` or `action-unconfirmed`."),
+            failedIndex: actionIndexSchema.describe("Index of the first action that did not take effect."),
+            failureReason: z
+                .enum(sequenceFailureReasons)
+                .describe("Why that action did not take effect, the same as on its entry in `results`."),
+            imageJpegBase64: screenshotImageSchema
+                .optional()
+                .describe(finalImageDescription),
+            lastCompletedIndex: actionIndexSchema
+                .optional()
+                .describe("Index of the last action that took effect. Absent when none did. With `stopOnFailure: false` it can follow a failed action, so `results` says which ones before it took effect."),
+            outcome: z.literal("failure"),
+            results: z
+                .array(stepResultSchema)
+                .min(1)
+                .max(maxActionsPerRequest)
+                .describe("One entry per action reached, in order. Actions after a stop have no entry."),
+            stoppedEarly: z
+                .boolean()
+                .describe("Whether actions after the failure were left unperformed. False when every action was attempted."),
+        }),
+    ]);
+    return {
+        annotations: {
+            destructiveHint: true,
+            openWorldHint: true,
+            readOnlyHint: false,
+        },
+        description: "Perform a sequence of raw browser actions on an interactive runner in one request, one after another, and answer with what happened to each. A `success` means every action took effect. A `failure` names the first action that did not (`failedIndex`, `failureReason`), the last one that did (`lastCompletedIndex`), and whether actions were left unperformed (`stoppedEarly`); `results` has one entry per action reached, in order. Read `effect` on an entry before sending its action again: `performed` means the runner did it; `not-performed` means the runner answered that it did not take effect, though a `navigate` that timed out may still be loading; `unknown` means the runner stopped answering with the action in flight (`runner-unreachable`), or its screen went quiet mid-action (`action-unconfirmed`), and it may have taken effect — a click that submitted a form, say — so take a screenshot instead of repeating it. A sequence gets about a minute to start its actions; an action it did not reach in time is `out-of-time`, nothing after it was attempted, and the rest can go in a new request. Everything `runner.performAction` says about a runner that has never run anything, a mobile runner, and the `screen-needs-a-run`, `screen-not-ready`, `runner-has-no-screen` and `action-not-supported-on-mobile` reasons holds for each action here.",
+        input,
+        kind: "write",
+        name: "runner.performActions",
+        output,
+    };
+};
+//# sourceMappingURL=performActions.js.map

package/dist/v1/runner/performActions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"performActions.js","sourceRoot":"","sources":["../../../src/v1/runner/performActions.ts"],"names":[],"mappings":"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"}

package/dist/v1/runner/performActionsSteps.d.ts

@@ -0,0 +1,85 @@
+import { z } from "zod";
+/** The reason on an action the sequence did not reach in time. */
+export declare const outOfTimeFailureReason = "out-of-time";
+/**
+ * The reason on an action the runner's screen went quiet on: it may have taken
+ * effect, and nothing after it was attempted.
+ */
+export declare const unconfirmedFailureReason = "action-unconfirmed";
+export declare const actionIndexSchema: z.ZodInt;
+export declare const performedStepSchema: z.ZodObject<{
+    effect: z.ZodLiteral<"performed">;
+    imageJpegBase64: z.ZodOptional<z.ZodString>;
+    index: z.ZodInt;
+    outcome: z.ZodLiteral<"success">;
+}, z.core.$strip>;
+export type PerformedActionStep = z.infer<typeof performedStepSchema>;
+export declare const failedStepSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    effect: z.ZodLiteral<"not-performed">;
+    errorMessage: z.ZodString;
+    failureReason: z.ZodLiteral<"action-failed">;
+    imageJpegBase64: z.ZodOptional<z.ZodString>;
+    index: z.ZodInt;
+    outcome: z.ZodLiteral<"failure">;
+}, z.core.$strip>, z.ZodObject<{
+    effect: z.ZodLiteral<"unknown">;
+    failureReason: z.ZodLiteral<"runner-unreachable">;
+    index: z.ZodInt;
+    outcome: z.ZodLiteral<"failure">;
+}, z.core.$strip>, z.ZodObject<{
+    effect: z.ZodLiteral<"unknown">;
+    errorMessage: z.ZodString;
+    failureReason: z.ZodLiteral<"action-unconfirmed">;
+    index: z.ZodInt;
+    outcome: z.ZodLiteral<"failure">;
+}, z.core.$strip>, z.ZodObject<{
+    effect: z.ZodLiteral<"not-performed">;
+    failureReason: z.ZodEnum<{
+        "screen-needs-a-run": "screen-needs-a-run";
+        "screen-not-ready": "screen-not-ready";
+        "runner-has-no-screen": "runner-has-no-screen";
+        "action-not-supported-on-mobile": "action-not-supported-on-mobile";
+        "out-of-time": "out-of-time";
+    }>;
+    index: z.ZodInt;
+    outcome: z.ZodLiteral<"failure">;
+}, z.core.$strip>], "failureReason">;
+export type FailedActionStep = z.infer<typeof failedStepSchema>;
+export declare const stepResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    effect: z.ZodLiteral<"performed">;
+    imageJpegBase64: z.ZodOptional<z.ZodString>;
+    index: z.ZodInt;
+    outcome: z.ZodLiteral<"success">;
+}, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    effect: z.ZodLiteral<"not-performed">;
+    errorMessage: z.ZodString;
+    failureReason: z.ZodLiteral<"action-failed">;
+    imageJpegBase64: z.ZodOptional<z.ZodString>;
+    index: z.ZodInt;
+    outcome: z.ZodLiteral<"failure">;
+}, z.core.$strip>, z.ZodObject<{
+    effect: z.ZodLiteral<"unknown">;
+    failureReason: z.ZodLiteral<"runner-unreachable">;
+    index: z.ZodInt;
+    outcome: z.ZodLiteral<"failure">;
+}, z.core.$strip>, z.ZodObject<{
+    effect: z.ZodLiteral<"unknown">;
+    errorMessage: z.ZodString;
+    failureReason: z.ZodLiteral<"action-unconfirmed">;
+    index: z.ZodInt;
+    outcome: z.ZodLiteral<"failure">;
+}, z.core.$strip>, z.ZodObject<{
+    effect: z.ZodLiteral<"not-performed">;
+    failureReason: z.ZodEnum<{
+        "screen-needs-a-run": "screen-needs-a-run";
+        "screen-not-ready": "screen-not-ready";
+        "runner-has-no-screen": "runner-has-no-screen";
+        "action-not-supported-on-mobile": "action-not-supported-on-mobile";
+        "out-of-time": "out-of-time";
+    }>;
+    index: z.ZodInt;
+    outcome: z.ZodLiteral<"failure">;
+}, z.core.$strip>], "failureReason">], "outcome">;
+export type ActionStepResult = z.infer<typeof stepResultSchema>;
+export declare const sequenceFailureReasons: readonly ["action-failed", "runner-has-no-screen", "screen-needs-a-run", "screen-not-ready", "action-not-supported-on-mobile", "out-of-time", "action-unconfirmed", "runner-unreachable"];
+//# sourceMappingURL=performActionsSteps.d.ts.map

package/dist/v1/runner/performActionsSteps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"performActionsSteps.d.ts","sourceRoot":"","sources":["../../../src/v1/runner/performActionsSteps.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,kEAAkE;AAClE,eAAO,MAAM,sBAAsB,gBAAgB,CAAC;AAEpD;;;GAGG;AACH,eAAO,MAAM,wBAAwB,uBAAuB,CAAC;AAE7D,eAAO,MAAM,iBAAiB,UAI2C,CAAC;AAI1E,eAAO,MAAM,mBAAmB;;;;;iBAK9B,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAMtE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAwC3B,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDAG3B,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE,eAAO,MAAM,sBAAsB,2LAOzB,CAAC"}

package/dist/v1/runner/performActionsSteps.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { maxActionsPerRequest } from "./actionSequence.js";
+import { maxActionErrorMessageLength } from "./performAction.js";
+import { screenFailureReasons, screenshotImageSchema } from "./screen.js";
+import { runnerUnreachableFailureReason } from "./unreachable.js";
+/** The reason on an action the sequence did not reach in time. */
+export const outOfTimeFailureReason = "out-of-time";
+/**
+ * The reason on an action the runner's screen went quiet on: it may have taken
+ * effect, and nothing after it was attempted.
+ */
+export const unconfirmedFailureReason = "action-unconfirmed";
+export const actionIndexSchema = z
+    .int()
+    .min(0)
+    .max(maxActionsPerRequest - 1)
+    .describe("Position of the action in the request's `actions`, from 0.");
+const screenshotAfterStep = screenshotImageSchema.optional();
+export const performedStepSchema = z.object({
+    effect: z.literal("performed"),
+    imageJpegBase64: screenshotAfterStep,
+    index: actionIndexSchema,
+    outcome: z.literal("success"),
+});
+// `effect` is fixed per reason rather than reported: a caller deciding whether
+// to send an action again needs the promise, not a field the server may fill
+// in differently one day. `runner-unreachable` and `action-unconfirmed` are
+// the reasons where the action may have taken effect without saying so.
+export const failedStepSchema = z.discriminatedUnion("failureReason", [
+    z.object({
+        effect: z.literal("not-performed"),
+        errorMessage: z
+            .string()
+            .max(maxActionErrorMessageLength)
+            .describe("What stopped the action from taking effect."),
+        failureReason: z.literal("action-failed"),
+        imageJpegBase64: screenshotAfterStep,
+        index: actionIndexSchema,
+        outcome: z.literal("failure"),
+    }),
+    z.object({
+        effect: z.literal("unknown"),
+        failureReason: z.literal(runnerUnreachableFailureReason),
+        index: actionIndexSchema,
+        outcome: z.literal("failure"),
+    }),
+    z.object({
+        effect: z.literal("unknown"),
+        errorMessage: z
+            .string()
+            .max(maxActionErrorMessageLength)
+            .describe("How the runner's screen went quiet with the action in flight."),
+        failureReason: z.literal(unconfirmedFailureReason),
+        index: actionIndexSchema,
+        outcome: z.literal("failure"),
+    }),
+    z.object({
+        effect: z.literal("not-performed"),
+        failureReason: z.enum([
+            ...screenFailureReasons,
+            "action-not-supported-on-mobile",
+            outOfTimeFailureReason,
+        ]),
+        index: actionIndexSchema,
+        outcome: z.literal("failure"),
+    }),
+]);
+export const stepResultSchema = z.discriminatedUnion("outcome", [
+    performedStepSchema,
+    failedStepSchema,
+]);
+export const sequenceFailureReasons = [
+    "action-failed",
+    ...screenFailureReasons,
+    "action-not-supported-on-mobile",
+    outOfTimeFailureReason,
+    unconfirmedFailureReason,
+    runnerUnreachableFailureReason,
+];
+//# sourceMappingURL=performActionsSteps.js.map

package/dist/v1/runner/performActionsSteps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"performActionsSteps.js","sourceRoot":"","sources":["../../../src/v1/runner/performActionsSteps.ts"],"names":[],"mappings":"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"}

package/dist/v1/runnerReexports.d.ts

@@ -1,3 +1,4 @@
+export { type ScreenshotMode, maxActionsPerRequest, screenshotModes, } from "./runner/actionSequence.js";
 export { type BrowserAction, browserActionSchema, maxTypedTextLength, } from "./runner/browserAction.js";
 export { runEnvironmentSchema } from "./runner/environment.js";
 export { isShippableRunFilePath, runFilePathSchema, runPackageJsonPath, shippableRunFileExtensions, } from "./runner/files.js";
@@ -7,5 +8,6 @@ export { type InspectMobileRequest, inspectMobileRequestSchema, } from "./runner
 export { type JournalEntry, type JournalStream, type KnownJournalStream, type ReadJournalRequest, type ReadJournalResponse, journalEntrySchema, journalStreamSchema, knownJournalStreams, maxJournalStreamNameLength, readJournalRequestSchema, readJournalResponseSchema, } from "./runner/journal.js";
 export { type RunFiles, maxRunFilesByteLength, maxRunnerRequestEncodedByteLength, runFilesByteLength, runFilesSchema, } from "./runner/payloadSize.js";
 export { maxActionErrorMessageLength } from "./runner/performAction.js";
+export { type ActionStepResult, type FailedActionStep, type PerformedActionStep, outOfTimeFailureReason, unconfirmedFailureReason, } from "./runner/performActions.js";
 export { type RunSelection, runSelectionSchema, } from "./runner/runSelection.js";
 //# sourceMappingURL=runnerReexports.d.ts.map

package/dist/v1/runnerReexports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runnerReexports.d.ts","sourceRoot":"","sources":["../../src/v1/runnerReexports.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,aAAa,EAClB,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,2BAA2B,CAAC;AAInC,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAK/D,OAAO,EACL,sBAAsB,EACtB,iBAAiB,EACjB,kBAAkB,EAClB,0BAA0B,GAC3B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,sBAAsB,EAC3B,gBAAgB,EAChB,cAAc,EACd,gBAAgB,GACjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,KAAK,sBAAsB,EAC3B,oBAAoB,GACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,KAAK,oBAAoB,EACzB,0BAA0B,GAC3B,MAAM,2BAA2B,CAAC;AAGnC,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,EACnB,0BAA0B,EAC1B,wBAAwB,EACxB,yBAAyB,GAC1B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,KAAK,QAAQ,EACb,qBAAqB,EACrB,iCAAiC,EACjC,kBAAkB,EAClB,cAAc,GACf,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,EACL,KAAK,YAAY,EACjB,kBAAkB,GACnB,MAAM,0BAA0B,CAAC"}
+{"version":3,"file":"runnerReexports.d.ts","sourceRoot":"","sources":["../../src/v1/runnerReexports.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,cAAc,EACnB,oBAAoB,EACpB,eAAe,GAChB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,KAAK,aAAa,EAClB,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,2BAA2B,CAAC;AAInC,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAK/D,OAAO,EACL,sBAAsB,EACtB,iBAAiB,EACjB,kBAAkB,EAClB,0BAA0B,GAC3B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,sBAAsB,EAC3B,gBAAgB,EAChB,cAAc,EACd,gBAAgB,GACjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,KAAK,sBAAsB,EAC3B,oBAAoB,GACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,KAAK,oBAAoB,EACzB,0BAA0B,GAC3B,MAAM,2BAA2B,CAAC;AAGnC,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,EACnB,0BAA0B,EAC1B,wBAAwB,EACxB,yBAAyB,GAC1B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,KAAK,QAAQ,EACb,qBAAqB,EACrB,iCAAiC,EACjC,kBAAkB,EAClB,cAAc,GACf,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,KAAK,YAAY,EACjB,kBAAkB,GACnB,MAAM,0BAA0B,CAAC"}

package/dist/v1/runnerReexports.js

@@ -1,6 +1,7 @@
 // The `runner` resource's shared types and schemas, re-exported here rather
 // than restated by every server and client that needs them. Split out of
 // `index.ts` to keep that file under the line limit.
+export { maxActionsPerRequest, screenshotModes, } from "./runner/actionSequence.js";
 export { browserActionSchema, maxTypedTextLength, } from "./runner/browserAction.js";
 // Carries the reservation of QA Wolf's own variable names, which the server
 // validates with rather than restating — a second copy of that rule is how the
@@ -19,5 +20,6 @@ export { inspectMobileRequestSchema, } from "./runner/inspectMobile.js";
 export { journalEntrySchema, journalStreamSchema, knownJournalStreams, maxJournalStreamNameLength, readJournalRequestSchema, readJournalResponseSchema, } from "./runner/journal.js";
 export { maxRunFilesByteLength, maxRunnerRequestEncodedByteLength, runFilesByteLength, runFilesSchema, } from "./runner/payloadSize.js";
 export { maxActionErrorMessageLength } from "./runner/performAction.js";
+export { outOfTimeFailureReason, unconfirmedFailureReason, } from "./runner/performActions.js";
 export { runSelectionSchema, } from "./runner/runSelection.js";
 //# sourceMappingURL=runnerReexports.js.map

package/dist/v1/runnerReexports.js.map

@@ -1 +1 @@
-{"version":3,"file":"runnerReexports.js","sourceRoot":"","sources":["../../src/v1/runnerReexports.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,yEAAyE;AACzE,qDAAqD;AACrD,OAAO,EAEL,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,2BAA2B,CAAC;AACnC,4EAA4E;AAC5E,+EAA+E;AAC/E,6DAA6D;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAC/D,iFAAiF;AACjF,iFAAiF;AACjF,+EAA+E;AAC/E,gFAAgF;AAChF,OAAO,EACL,sBAAsB,EACtB,iBAAiB,EACjB,kBAAkB,EAClB,0BAA0B,GAC3B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAEL,gBAAgB,EAChB,cAAc,EACd,gBAAgB,GACjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAEL,oBAAoB,GACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAEL,0BAA0B,GAC3B,MAAM,2BAA2B,CAAC;AACnC,gFAAgF;AAChF,yEAAyE;AACzE,OAAO,EAML,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,EACnB,0BAA0B,EAC1B,wBAAwB,EACxB,yBAAyB,GAC1B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAEL,qBAAqB,EACrB,iCAAiC,EACjC,kBAAkB,EAClB,cAAc,GACf,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,EAEL,kBAAkB,GACnB,MAAM,0BAA0B,CAAC"}
+{"version":3,"file":"runnerReexports.js","sourceRoot":"","sources":["../../src/v1/runnerReexports.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,yEAAyE;AACzE,qDAAqD;AACrD,OAAO,EAEL,oBAAoB,EACpB,eAAe,GAChB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAEL,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,2BAA2B,CAAC;AACnC,4EAA4E;AAC5E,+EAA+E;AAC/E,6DAA6D;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAC/D,iFAAiF;AACjF,iFAAiF;AACjF,+EAA+E;AAC/E,gFAAgF;AAChF,OAAO,EACL,sBAAsB,EACtB,iBAAiB,EACjB,kBAAkB,EAClB,0BAA0B,GAC3B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAEL,gBAAgB,EAChB,cAAc,EACd,gBAAgB,GACjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAEL,oBAAoB,GACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAEL,0BAA0B,GAC3B,MAAM,2BAA2B,CAAC;AACnC,gFAAgF;AAChF,yEAAyE;AACzE,OAAO,EAML,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,EACnB,0BAA0B,EAC1B,wBAAwB,EACxB,yBAAyB,GAC1B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAEL,qBAAqB,EACrB,iCAAiC,EACjC,kBAAkB,EAClB,cAAc,GACf,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,EAIL,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAEL,kBAAkB,GACnB,MAAM,0BAA0B,CAAC"}

package/dist/v1/skill/index.d.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+export declare const makeListSkillsContract: () => {
+    readonly annotations: {
+        readonly destructiveHint: false;
+        readonly openWorldHint: false;
+        readonly readOnlyHint: true;
+    };
+    readonly description: "List the QA Wolf skills, each with its name and the description that says when to use it. A skill is the instructions a coding agent follows for one kind of QA Wolf work, such as onboarding an application, creating a flow, repairing a failing flow, or setting up triggers. Call this before any QA Wolf work, pick the skill whose description matches the request, and read it with skill.get.";
+    readonly input: z.ZodObject<{}, z.core.$strip>;
+    readonly kind: "read";
+    readonly name: "skill.list";
+    readonly output: z.ZodObject<{
+        skills: z.ZodArray<z.ZodObject<{
+            description: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+};
+export declare const makeGetSkillContract: () => {
+    readonly annotations: {
+        readonly destructiveHint: false;
+        readonly openWorldHint: false;
+        readonly readOnlyHint: true;
+    };
+    readonly description: "Read a QA Wolf skill: the instructions a coding agent follows for one kind of QA Wolf work. The reply carries the skill's SKILL.md and every file under its references directory, so nothing else has to be fetched for it. Read the skill before starting the work it covers and follow it. A link in the reply of the form ../<skill>/SKILL.md names another skill, which this call reads by that name.";
+    readonly input: z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strip>;
+    readonly kind: "read";
+    readonly name: "skill.get";
+    readonly output: z.ZodObject<{
+        description: z.ZodString;
+        name: z.ZodString;
+        instructions: z.ZodString;
+        references: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+};
+export declare const makeSkillContracts: () => {
+    get: {
+        readonly annotations: {
+            readonly destructiveHint: false;
+            readonly openWorldHint: false;
+            readonly readOnlyHint: true;
+        };
+        readonly description: "Read a QA Wolf skill: the instructions a coding agent follows for one kind of QA Wolf work. The reply carries the skill's SKILL.md and every file under its references directory, so nothing else has to be fetched for it. Read the skill before starting the work it covers and follow it. A link in the reply of the form ../<skill>/SKILL.md names another skill, which this call reads by that name.";
+        readonly input: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>;
+        readonly kind: "read";
+        readonly name: "skill.get";
+        readonly output: z.ZodObject<{
+            description: z.ZodString;
+            name: z.ZodString;
+            instructions: z.ZodString;
+            references: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                text: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    list: {
+        readonly annotations: {
+            readonly destructiveHint: false;
+            readonly openWorldHint: false;
+            readonly readOnlyHint: true;
+        };
+        readonly description: "List the QA Wolf skills, each with its name and the description that says when to use it. A skill is the instructions a coding agent follows for one kind of QA Wolf work, such as onboarding an application, creating a flow, repairing a failing flow, or setting up triggers. Call this before any QA Wolf work, pick the skill whose description matches the request, and read it with skill.get.";
+        readonly input: z.ZodObject<{}, z.core.$strip>;
+        readonly kind: "read";
+        readonly name: "skill.list";
+        readonly output: z.ZodObject<{
+            skills: z.ZodArray<z.ZodObject<{
+                description: z.ZodString;
+                name: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/v1/skill/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/v1/skill/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA0BxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;CAsBlC,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;CAgChC,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG7B,CAAC"}

package/dist/v1/skill/index.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+const skillName = z
+    .string()
+    .trim()
+    .min(1)
+    .max(255)
+    .describe("The skill's name as skill.list reports it, such as qawolf-onboarding. The qawolf- prefix is optional, so onboarding names the same skill.");
+const skillSummary = z.object({
+    description: z
+        .string()
+        .describe("When to use the skill, in the words the agent routes on."),
+    name: z.string().describe("The skill's name. Read it with skill.get."),
+});
+const readOnlyAnnotations = {
+    destructiveHint: false,
+    openWorldHint: false,
+    readOnlyHint: true,
+};
+export const makeListSkillsContract = () => {
+    const input = z.object({});
+    const output = z.object({
+        skills: z
+            .array(skillSummary)
+            .describe("Every skill the server serves, in catalog order."),
+    });
+    return {
+        annotations: readOnlyAnnotations,
+        description: "List the QA Wolf skills, each with its name and the description that says when to use it. A skill is the instructions a coding agent follows for one kind of QA Wolf work, such as onboarding an application, creating a flow, repairing a failing flow, or setting up triggers. Call this before any QA Wolf work, pick the skill whose description matches the request, and read it with skill.get.",
+        input,
+        kind: "read",
+        name: "skill.list",
+        output,
+    };
+};
+export const makeGetSkillContract = () => {
+    const input = z.object({ name: skillName });
+    const output = skillSummary.extend({
+        instructions: z
+            .string()
+            .describe("The skill's SKILL.md, frontmatter included."),
+        references: z
+            .array(z.object({
+            path: z
+                .string()
+                .describe("The file's path relative to the skill directory."),
+            text: z.string().describe("The file's content."),
+        }))
+            .describe("The files the skill links to under its directory."),
+    });
+    return {
+        annotations: readOnlyAnnotations,
+        description: "Read a QA Wolf skill: the instructions a coding agent follows for one kind of QA Wolf work. The reply carries the skill's SKILL.md and every file under its references directory, so nothing else has to be fetched for it. Read the skill before starting the work it covers and follow it. A link in the reply of the form ../<skill>/SKILL.md names another skill, which this call reads by that name.",
+        input,
+        kind: "read",
+        name: "skill.get",
+        output,
+    };
+};
+export const makeSkillContracts = () => ({
+    get: makeGetSkillContract(),
+    list: makeListSkillsContract(),
+});
+//# sourceMappingURL=index.js.map