@executioncontrolprotocol/types 0.10.0

package/dist/harness-run-context.d.ts

@@ -0,0 +1,228 @@
+import { z } from "zod";
+import type { RunResult } from "./run.js";
+import type { WorkflowManifest } from "./workflow.js";
+/** Zod mirror of per-step run history (eval fixtures). @category Harness */
+export declare const stepRunRecordSchema: z.ZodObject<{
+    status: z.ZodString;
+    output: z.ZodOptional<z.ZodUnknown>;
+    committedAs: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    attempts: z.ZodOptional<z.ZodNumber>;
+    usage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    mutations: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    status: string;
+    output?: unknown;
+    committedAs?: string | null | undefined;
+    attempts?: number | undefined;
+    usage?: Record<string, unknown> | undefined;
+    mutations?: Record<string, unknown>[] | undefined;
+}, {
+    status: string;
+    output?: unknown;
+    committedAs?: string | null | undefined;
+    attempts?: number | undefined;
+    usage?: Record<string, unknown> | undefined;
+    mutations?: Record<string, unknown>[] | undefined;
+}>;
+/** Zod mirror of run result document (eval fixtures). @category Harness */
+export declare const runResultSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"@executioncontrolprotocol.run.result">;
+    version: z.ZodString;
+    run: z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        status: string;
+        id: string;
+    }, {
+        status: string;
+        id: string;
+    }>;
+    state: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    history: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        status: z.ZodString;
+        output: z.ZodOptional<z.ZodUnknown>;
+        committedAs: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        attempts: z.ZodOptional<z.ZodNumber>;
+        usage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        mutations: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        status: string;
+        output?: unknown;
+        committedAs?: string | null | undefined;
+        attempts?: number | undefined;
+        usage?: Record<string, unknown> | undefined;
+        mutations?: Record<string, unknown>[] | undefined;
+    }, {
+        status: string;
+        output?: unknown;
+        committedAs?: string | null | undefined;
+        attempts?: number | undefined;
+        usage?: Record<string, unknown> | undefined;
+        mutations?: Record<string, unknown>[] | undefined;
+    }>>>;
+    usage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    run: {
+        status: string;
+        id: string;
+    };
+    schema: "@executioncontrolprotocol.run.result";
+    usage?: Record<string, unknown> | undefined;
+    state?: Record<string, unknown> | undefined;
+    history?: Record<string, {
+        status: string;
+        output?: unknown;
+        committedAs?: string | null | undefined;
+        attempts?: number | undefined;
+        usage?: Record<string, unknown> | undefined;
+        mutations?: Record<string, unknown>[] | undefined;
+    }> | undefined;
+}, {
+    version: string;
+    run: {
+        status: string;
+        id: string;
+    };
+    schema: "@executioncontrolprotocol.run.result";
+    usage?: Record<string, unknown> | undefined;
+    state?: Record<string, unknown> | undefined;
+    history?: Record<string, {
+        status: string;
+        output?: unknown;
+        committedAs?: string | null | undefined;
+        attempts?: number | undefined;
+        usage?: Record<string, unknown> | undefined;
+        mutations?: Record<string, unknown>[] | undefined;
+    }> | undefined;
+}>;
+/** Snapshot passed into harnesses for run-aware assistance. @category Harness */
+export interface HarnessRunContext {
+    /** Result from ecp.run() or equivalent. */
+    run: RunResult;
+    /** Workflow manifest when the run was started (optional but recommended). */
+    workflow?: WorkflowManifest;
+}
+/** Zod schema for {@link HarnessRunContext}. @category Harness */
+export declare const harnessRunContextSchema: z.ZodObject<{
+    run: z.ZodObject<{
+        schema: z.ZodLiteral<"@executioncontrolprotocol.run.result">;
+        version: z.ZodString;
+        run: z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            status: string;
+            id: string;
+        }, {
+            status: string;
+            id: string;
+        }>;
+        state: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        history: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            status: z.ZodString;
+            output: z.ZodOptional<z.ZodUnknown>;
+            committedAs: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            attempts: z.ZodOptional<z.ZodNumber>;
+            usage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            mutations: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            status: string;
+            output?: unknown;
+            committedAs?: string | null | undefined;
+            attempts?: number | undefined;
+            usage?: Record<string, unknown> | undefined;
+            mutations?: Record<string, unknown>[] | undefined;
+        }, {
+            status: string;
+            output?: unknown;
+            committedAs?: string | null | undefined;
+            attempts?: number | undefined;
+            usage?: Record<string, unknown> | undefined;
+            mutations?: Record<string, unknown>[] | undefined;
+        }>>>;
+        usage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        version: string;
+        run: {
+            status: string;
+            id: string;
+        };
+        schema: "@executioncontrolprotocol.run.result";
+        usage?: Record<string, unknown> | undefined;
+        state?: Record<string, unknown> | undefined;
+        history?: Record<string, {
+            status: string;
+            output?: unknown;
+            committedAs?: string | null | undefined;
+            attempts?: number | undefined;
+            usage?: Record<string, unknown> | undefined;
+            mutations?: Record<string, unknown>[] | undefined;
+        }> | undefined;
+    }, {
+        version: string;
+        run: {
+            status: string;
+            id: string;
+        };
+        schema: "@executioncontrolprotocol.run.result";
+        usage?: Record<string, unknown> | undefined;
+        state?: Record<string, unknown> | undefined;
+        history?: Record<string, {
+            status: string;
+            output?: unknown;
+            committedAs?: string | null | undefined;
+            attempts?: number | undefined;
+            usage?: Record<string, unknown> | undefined;
+            mutations?: Record<string, unknown>[] | undefined;
+        }> | undefined;
+    }>;
+    workflow: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    run: {
+        version: string;
+        run: {
+            status: string;
+            id: string;
+        };
+        schema: "@executioncontrolprotocol.run.result";
+        usage?: Record<string, unknown> | undefined;
+        state?: Record<string, unknown> | undefined;
+        history?: Record<string, {
+            status: string;
+            output?: unknown;
+            committedAs?: string | null | undefined;
+            attempts?: number | undefined;
+            usage?: Record<string, unknown> | undefined;
+            mutations?: Record<string, unknown>[] | undefined;
+        }> | undefined;
+    };
+    workflow?: Record<string, unknown> | undefined;
+}, {
+    run: {
+        version: string;
+        run: {
+            status: string;
+            id: string;
+        };
+        schema: "@executioncontrolprotocol.run.result";
+        usage?: Record<string, unknown> | undefined;
+        state?: Record<string, unknown> | undefined;
+        history?: Record<string, {
+            status: string;
+            output?: unknown;
+            committedAs?: string | null | undefined;
+            attempts?: number | undefined;
+            usage?: Record<string, unknown> | undefined;
+            mutations?: Record<string, unknown>[] | undefined;
+        }> | undefined;
+    };
+    workflow?: Record<string, unknown> | undefined;
+}>;
+/**
+ * Build harness run context from a live run (single adapter for runtime + eval loaders).
+ * @category Harness
+ */
+export declare function toHarnessRunContext(run: RunResult, workflow?: WorkflowManifest): HarnessRunContext;
+//# sourceMappingURL=harness-run-context.d.ts.map

package/dist/harness-run-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness-run-context.d.ts","sourceRoot":"","sources":["../src/harness-run-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AACzC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAErD,4EAA4E;AAC5E,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;EAO9B,CAAA;AAEF,2EAA2E;AAC3E,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAU1B,CAAA;AAEF,iFAAiF;AACjF,MAAM,WAAW,iBAAiB;IAChC,2CAA2C;IAC3C,GAAG,EAAE,SAAS,CAAA;IACd,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,gBAAgB,CAAA;CAC5B;AAED,kEAAkE;AAClE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGlC,CAAA;AAEF;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,SAAS,EACd,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,iBAAiB,CAEnB"}

package/dist/harness-run-context.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+/** Zod mirror of per-step run history (eval fixtures). @category Harness */
+export const stepRunRecordSchema = z.object({
+    status: z.string(),
+    output: z.unknown().optional(),
+    committedAs: z.string().nullable().optional(),
+    attempts: z.number().optional(),
+    usage: z.record(z.string(), z.unknown()).optional(),
+    mutations: z.array(z.record(z.string(), z.unknown())).optional(),
+});
+/** Zod mirror of run result document (eval fixtures). @category Harness */
+export const runResultSchema = z.object({
+    schema: z.literal("@executioncontrolprotocol.run.result"),
+    version: z.string(),
+    run: z.object({
+        id: z.string(),
+        status: z.string(),
+    }),
+    state: z.record(z.string(), z.unknown()).optional(),
+    history: z.record(z.string(), stepRunRecordSchema).optional(),
+    usage: z.record(z.string(), z.unknown()).optional(),
+});
+/** Zod schema for {@link HarnessRunContext}. @category Harness */
+export const harnessRunContextSchema = z.object({
+    run: runResultSchema,
+    workflow: z.record(z.string(), z.unknown()).optional(),
+});
+/**
+ * Build harness run context from a live run (single adapter for runtime + eval loaders).
+ * @category Harness
+ */
+export function toHarnessRunContext(run, workflow) {
+    return workflow !== undefined ? { run, workflow } : { run };
+}
+//# sourceMappingURL=harness-run-context.js.map

package/dist/harness-run-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness-run-context.js","sourceRoot":"","sources":["../src/harness-run-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,4EAA4E;AAC5E,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;IAClB,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IAC9B,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IAC7C,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC/B,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE;IACnD,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE;CACjE,CAAC,CAAA;AAEF,2EAA2E;AAC3E,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC;IACtC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,sCAAsC,CAAC;IACzD,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,GAAG,EAAE,CAAC,CAAC,MAAM,CAAC;QACZ,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;QACd,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;KACnB,CAAC;IACF,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE;IACnD,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,mBAAmB,CAAC,CAAC,QAAQ,EAAE;IAC7D,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE;CACpD,CAAC,CAAA;AAUF,kEAAkE;AAClE,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC9C,GAAG,EAAE,eAAe;IACpB,QAAQ,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE;CACvD,CAAC,CAAA;AAEF;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CACjC,GAAc,EACd,QAA2B;IAE3B,OAAO,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAA;AAC7D,CAAC"}

package/dist/harness-tasks.d.ts

@@ -0,0 +1,403 @@
+import { z } from "zod";
+/** Shared harness task ids for browser and third-party harnesses. @category Harness */
+export declare const HARNESS_TASK_IDS: {
+    readonly WORKFLOW_AUTHORING: "workflow-authoring";
+    readonly INTENT_CLASSIFICATION: "intent-classification";
+    readonly WORKFLOW_ASSISTANT: "workflow-assistant";
+    readonly CHAT: "chat";
+};
+/** Harness task id union. @category Harness */
+export type HarnessTaskId = (typeof HARNESS_TASK_IDS)[keyof typeof HARNESS_TASK_IDS];
+/** Intent classification harness input. @category Harness */
+export declare const harnessIntentClassificationInputSchema: z.ZodObject<{
+    /** User message to classify. */
+    message: z.ZodString;
+    /** Optional model override. */
+    model: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    model?: string | undefined;
+}, {
+    message: string;
+    model?: string | undefined;
+}>;
+/** Workflow authoring harness input. @category Harness */
+export declare const harnessWorkflowAuthoringInputSchema: z.ZodObject<{
+    /** Authoring request text. */
+    request: z.ZodString;
+    /** Baseline manifest for patch mode. */
+    manifest: z.ZodOptional<z.ZodUnknown>;
+    /** Optional model override. */
+    model: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    request: string;
+    model?: string | undefined;
+    manifest?: unknown;
+}, {
+    request: string;
+    model?: string | undefined;
+    manifest?: unknown;
+}>;
+/** Multi-shot chat harness input (intent shot + contextualized execution). @category Harness */
+export declare const harnessChatInputSchema: z.ZodObject<{
+    /** User message. */
+    message: z.ZodString;
+    /** Baseline manifest for patch routing. */
+    manifest: z.ZodOptional<z.ZodUnknown>;
+    /** Optional run context for assistant routing. */
+    runContext: z.ZodOptional<z.ZodObject<{
+        run: z.ZodObject<{
+            schema: z.ZodLiteral<"@executioncontrolprotocol.run.result">;
+            version: z.ZodString;
+            run: z.ZodObject<{
+                id: z.ZodString;
+                status: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                status: string;
+                id: string;
+            }, {
+                status: string;
+                id: string;
+            }>;
+            state: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            history: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                status: z.ZodString;
+                output: z.ZodOptional<z.ZodUnknown>;
+                committedAs: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                attempts: z.ZodOptional<z.ZodNumber>;
+                usage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                mutations: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                status: string;
+                output?: unknown;
+                committedAs?: string | null | undefined;
+                attempts?: number | undefined;
+                usage?: Record<string, unknown> | undefined;
+                mutations?: Record<string, unknown>[] | undefined;
+            }, {
+                status: string;
+                output?: unknown;
+                committedAs?: string | null | undefined;
+                attempts?: number | undefined;
+                usage?: Record<string, unknown> | undefined;
+                mutations?: Record<string, unknown>[] | undefined;
+            }>>>;
+            usage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            version: string;
+            run: {
+                status: string;
+                id: string;
+            };
+            schema: "@executioncontrolprotocol.run.result";
+            usage?: Record<string, unknown> | undefined;
+            state?: Record<string, unknown> | undefined;
+            history?: Record<string, {
+                status: string;
+                output?: unknown;
+                committedAs?: string | null | undefined;
+                attempts?: number | undefined;
+                usage?: Record<string, unknown> | undefined;
+                mutations?: Record<string, unknown>[] | undefined;
+            }> | undefined;
+        }, {
+            version: string;
+            run: {
+                status: string;
+                id: string;
+            };
+            schema: "@executioncontrolprotocol.run.result";
+            usage?: Record<string, unknown> | undefined;
+            state?: Record<string, unknown> | undefined;
+            history?: Record<string, {
+                status: string;
+                output?: unknown;
+                committedAs?: string | null | undefined;
+                attempts?: number | undefined;
+                usage?: Record<string, unknown> | undefined;
+                mutations?: Record<string, unknown>[] | undefined;
+            }> | undefined;
+        }>;
+        workflow: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        run: {
+            version: string;
+            run: {
+                status: string;
+                id: string;
+            };
+            schema: "@executioncontrolprotocol.run.result";
+            usage?: Record<string, unknown> | undefined;
+            state?: Record<string, unknown> | undefined;
+            history?: Record<string, {
+                status: string;
+                output?: unknown;
+                committedAs?: string | null | undefined;
+                attempts?: number | undefined;
+                usage?: Record<string, unknown> | undefined;
+                mutations?: Record<string, unknown>[] | undefined;
+            }> | undefined;
+        };
+        workflow?: Record<string, unknown> | undefined;
+    }, {
+        run: {
+            version: string;
+            run: {
+                status: string;
+                id: string;
+            };
+            schema: "@executioncontrolprotocol.run.result";
+            usage?: Record<string, unknown> | undefined;
+            state?: Record<string, unknown> | undefined;
+            history?: Record<string, {
+                status: string;
+                output?: unknown;
+                committedAs?: string | null | undefined;
+                attempts?: number | undefined;
+                usage?: Record<string, unknown> | undefined;
+                mutations?: Record<string, unknown>[] | undefined;
+            }> | undefined;
+        };
+        workflow?: Record<string, unknown> | undefined;
+    }>>;
+    /** Rolling conversation summary supplied by the caller between turns. */
+    conversationSummary: z.ZodOptional<z.ZodString>;
+    /** Optional model override. */
+    model: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    model?: string | undefined;
+    manifest?: unknown;
+    runContext?: {
+        run: {
+            version: string;
+            run: {
+                status: string;
+                id: string;
+            };
+            schema: "@executioncontrolprotocol.run.result";
+            usage?: Record<string, unknown> | undefined;
+            state?: Record<string, unknown> | undefined;
+            history?: Record<string, {
+                status: string;
+                output?: unknown;
+                committedAs?: string | null | undefined;
+                attempts?: number | undefined;
+                usage?: Record<string, unknown> | undefined;
+                mutations?: Record<string, unknown>[] | undefined;
+            }> | undefined;
+        };
+        workflow?: Record<string, unknown> | undefined;
+    } | undefined;
+    conversationSummary?: string | undefined;
+}, {
+    message: string;
+    model?: string | undefined;
+    manifest?: unknown;
+    runContext?: {
+        run: {
+            version: string;
+            run: {
+                status: string;
+                id: string;
+            };
+            schema: "@executioncontrolprotocol.run.result";
+            usage?: Record<string, unknown> | undefined;
+            state?: Record<string, unknown> | undefined;
+            history?: Record<string, {
+                status: string;
+                output?: unknown;
+                committedAs?: string | null | undefined;
+                attempts?: number | undefined;
+                usage?: Record<string, unknown> | undefined;
+                mutations?: Record<string, unknown>[] | undefined;
+            }> | undefined;
+        };
+        workflow?: Record<string, unknown> | undefined;
+    } | undefined;
+    conversationSummary?: string | undefined;
+}>;
+/** Multi-shot chat input type. @category Harness */
+export type HarnessChatInput = z.infer<typeof harnessChatInputSchema>;
+/** Unified workflow assistant harness input. @category Harness */
+export declare const harnessWorkflowAssistantInputSchema: z.ZodObject<{
+    /** User message. */
+    message: z.ZodString;
+    /** Optional model override. */
+    model: z.ZodOptional<z.ZodString>;
+    /** Optional run context for run-aware Q&A. */
+    runContext: z.ZodOptional<z.ZodObject<{
+        run: z.ZodObject<{
+            schema: z.ZodLiteral<"@executioncontrolprotocol.run.result">;
+            version: z.ZodString;
+            run: z.ZodObject<{
+                id: z.ZodString;
+                status: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                status: string;
+                id: string;
+            }, {
+                status: string;
+                id: string;
+            }>;
+            state: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            history: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                status: z.ZodString;
+                output: z.ZodOptional<z.ZodUnknown>;
+                committedAs: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                attempts: z.ZodOptional<z.ZodNumber>;
+                usage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                mutations: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                status: string;
+                output?: unknown;
+                committedAs?: string | null | undefined;
+                attempts?: number | undefined;
+                usage?: Record<string, unknown> | undefined;
+                mutations?: Record<string, unknown>[] | undefined;
+            }, {
+                status: string;
+                output?: unknown;
+                committedAs?: string | null | undefined;
+                attempts?: number | undefined;
+                usage?: Record<string, unknown> | undefined;
+                mutations?: Record<string, unknown>[] | undefined;
+            }>>>;
+            usage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            version: string;
+            run: {
+                status: string;
+                id: string;
+            };
+            schema: "@executioncontrolprotocol.run.result";
+            usage?: Record<string, unknown> | undefined;
+            state?: Record<string, unknown> | undefined;
+            history?: Record<string, {
+                status: string;
+                output?: unknown;
+                committedAs?: string | null | undefined;
+                attempts?: number | undefined;
+                usage?: Record<string, unknown> | undefined;
+                mutations?: Record<string, unknown>[] | undefined;
+            }> | undefined;
+        }, {
+            version: string;
+            run: {
+                status: string;
+                id: string;
+            };
+            schema: "@executioncontrolprotocol.run.result";
+            usage?: Record<string, unknown> | undefined;
+            state?: Record<string, unknown> | undefined;
+            history?: Record<string, {
+                status: string;
+                output?: unknown;
+                committedAs?: string | null | undefined;
+                attempts?: number | undefined;
+                usage?: Record<string, unknown> | undefined;
+                mutations?: Record<string, unknown>[] | undefined;
+            }> | undefined;
+        }>;
+        workflow: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        run: {
+            version: string;
+            run: {
+                status: string;
+                id: string;
+            };
+            schema: "@executioncontrolprotocol.run.result";
+            usage?: Record<string, unknown> | undefined;
+            state?: Record<string, unknown> | undefined;
+            history?: Record<string, {
+                status: string;
+                output?: unknown;
+                committedAs?: string | null | undefined;
+                attempts?: number | undefined;
+                usage?: Record<string, unknown> | undefined;
+                mutations?: Record<string, unknown>[] | undefined;
+            }> | undefined;
+        };
+        workflow?: Record<string, unknown> | undefined;
+    }, {
+        run: {
+            version: string;
+            run: {
+                status: string;
+                id: string;
+            };
+            schema: "@executioncontrolprotocol.run.result";
+            usage?: Record<string, unknown> | undefined;
+            state?: Record<string, unknown> | undefined;
+            history?: Record<string, {
+                status: string;
+                output?: unknown;
+                committedAs?: string | null | undefined;
+                attempts?: number | undefined;
+                usage?: Record<string, unknown> | undefined;
+                mutations?: Record<string, unknown>[] | undefined;
+            }> | undefined;
+        };
+        workflow?: Record<string, unknown> | undefined;
+    }>>;
+    /** Optional workflow manifest summary context. */
+    workflow: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    workflow?: Record<string, unknown> | undefined;
+    model?: string | undefined;
+    runContext?: {
+        run: {
+            version: string;
+            run: {
+                status: string;
+                id: string;
+            };
+            schema: "@executioncontrolprotocol.run.result";
+            usage?: Record<string, unknown> | undefined;
+            state?: Record<string, unknown> | undefined;
+            history?: Record<string, {
+                status: string;
+                output?: unknown;
+                committedAs?: string | null | undefined;
+                attempts?: number | undefined;
+                usage?: Record<string, unknown> | undefined;
+                mutations?: Record<string, unknown>[] | undefined;
+            }> | undefined;
+        };
+        workflow?: Record<string, unknown> | undefined;
+    } | undefined;
+}, {
+    message: string;
+    workflow?: Record<string, unknown> | undefined;
+    model?: string | undefined;
+    runContext?: {
+        run: {
+            version: string;
+            run: {
+                status: string;
+                id: string;
+            };
+            schema: "@executioncontrolprotocol.run.result";
+            usage?: Record<string, unknown> | undefined;
+            state?: Record<string, unknown> | undefined;
+            history?: Record<string, {
+                status: string;
+                output?: unknown;
+                committedAs?: string | null | undefined;
+                attempts?: number | undefined;
+                usage?: Record<string, unknown> | undefined;
+                mutations?: Record<string, unknown>[] | undefined;
+            }> | undefined;
+        };
+        workflow?: Record<string, unknown> | undefined;
+    } | undefined;
+}>;
+/** Intent classification input type. @category Harness */
+export type HarnessIntentClassificationInput = z.infer<typeof harnessIntentClassificationInputSchema>;
+/** Workflow authoring input type. @category Harness */
+export type HarnessWorkflowAuthoringInput = z.infer<typeof harnessWorkflowAuthoringInputSchema>;
+/** Workflow assistant input type. @category Harness */
+export type HarnessWorkflowAssistantInput = z.infer<typeof harnessWorkflowAssistantInputSchema>;
+//# sourceMappingURL=harness-tasks.d.ts.map

package/dist/harness-tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness-tasks.d.ts","sourceRoot":"","sources":["../src/harness-tasks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,uFAAuF;AACvF,eAAO,MAAM,gBAAgB;;;;;CAKnB,CAAA;AAEV,+CAA+C;AAC/C,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,OAAO,gBAAgB,CAAC,CAAA;AAEpF,6DAA6D;AAC7D,eAAO,MAAM,sCAAsC;IACjD,gCAAgC;;IAEhC,+BAA+B;;;;;;;;EAE/B,CAAA;AAEF,0DAA0D;AAC1D,eAAO,MAAM,mCAAmC;IAC9C,8BAA8B;;IAE9B,wCAAwC;;IAExC,+BAA+B;;;;;;;;;;EAE/B,CAAA;AAEF,gGAAgG;AAChG,eAAO,MAAM,sBAAsB;IACjC,oBAAoB;;IAEpB,2CAA2C;;IAE3C,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAElD,yEAAyE;;IAEzE,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE/B,CAAA;AAEF,oDAAoD;AACpD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,kEAAkE;AAClE,eAAO,MAAM,mCAAmC;IAC9C,oBAAoB;;IAEpB,+BAA+B;;IAE/B,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAE9C,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAElD,CAAA;AAEF,0DAA0D;AAC1D,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CACpD,OAAO,sCAAsC,CAC9C,CAAA;AAED,uDAAuD;AACvD,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAE/F,uDAAuD;AACvD,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA"}