@nyxa/automation 0.1.0

package/dist/schema.js

@@ -0,0 +1,516 @@
+const schemaOutput = Symbol.for("@nyxa/automation/schema-output");
+const schemaOptional = Symbol.for("@nyxa/automation/schema-optional");
+const schemaParser = Symbol.for("@nyxa/automation/schema-parser");
+const schemaJson = Symbol.for("@nyxa/automation/schema-json");
+export class SchemaValidationError extends Error {
+    issues;
+    constructor(issues) {
+        super("Schema validation failed.");
+        this.name = "SchemaValidationError";
+        this.issues = Object.freeze([...issues]);
+    }
+}
+class BaseSchema {
+    [schemaOptional];
+    #description;
+    constructor(optional, description) {
+        this[schemaOptional] = optional;
+        this.#description = description;
+    }
+    get description() {
+        return this.#description;
+    }
+    parse(value) {
+        const result = this[schemaParser](value, []);
+        if (result.issues.length > 0) {
+            throw new SchemaValidationError(result.issues);
+        }
+        return result.value;
+    }
+    safeParse(value) {
+        const result = this[schemaParser](value, []);
+        return result.issues.length === 0
+            ? { success: true, data: result.value }
+            : { success: false, error: new SchemaValidationError(result.issues) };
+    }
+    describe(description) {
+        if (description.length === 0) {
+            throw new TypeError("A schema description cannot be empty.");
+        }
+        return this.cloneWithDescription(description);
+    }
+    nullable() {
+        return new NullableSchema(this, this[schemaOptional]);
+    }
+    optional() {
+        if (this[schemaOptional]) {
+            return this;
+        }
+        return new OptionalSchema(this);
+    }
+    toJSONSchema() {
+        const jsonSchema = this[schemaJson]();
+        return this.#description === undefined
+            ? jsonSchema
+            : { ...jsonSchema, description: this.#description };
+    }
+}
+export class StringSchema extends BaseSchema {
+    #constraints;
+    constructor(constraints = {
+        maximumLength: undefined,
+        minimumLength: undefined,
+        pattern: undefined,
+    }, description) {
+        super(false, description);
+        this.#constraints = constraints;
+    }
+    minLength(minimumLength) {
+        assertNonNegativeInteger(minimumLength, "minimum length");
+        return new StringSchema({ ...this.#constraints, minimumLength }, this.description);
+    }
+    maxLength(maximumLength) {
+        assertNonNegativeInteger(maximumLength, "maximum length");
+        return new StringSchema({ ...this.#constraints, maximumLength }, this.description);
+    }
+    pattern(pattern) {
+        new RegExp(pattern);
+        return new StringSchema({ ...this.#constraints, pattern }, this.description);
+    }
+    cloneWithDescription(description) {
+        return new StringSchema(this.#constraints, description);
+    }
+    [schemaParser](value, path) {
+        if (typeof value !== "string") {
+            return { issues: [invalidTypeIssue(path, "string", value)] };
+        }
+        const issues = [];
+        const length = [...value].length;
+        const { maximumLength, minimumLength, pattern } = this.#constraints;
+        if (minimumLength !== undefined && length < minimumLength) {
+            issues.push(tooSmallIssue(path, `String must contain at least ${minimumLength} characters.`, minimumLength));
+        }
+        if (maximumLength !== undefined && length > maximumLength) {
+            issues.push(tooBigIssue(path, `String must contain at most ${maximumLength} characters.`, maximumLength));
+        }
+        if (pattern !== undefined && !new RegExp(pattern).test(value)) {
+            issues.push({
+                code: "invalid_string",
+                path,
+                message: `String must match pattern ${pattern}.`,
+                pattern,
+            });
+        }
+        return { value, issues };
+    }
+    [schemaJson]() {
+        const { maximumLength, minimumLength, pattern } = this.#constraints;
+        return compactJsonSchema({
+            type: "string",
+            minLength: minimumLength,
+            maxLength: maximumLength,
+            pattern,
+        });
+    }
+}
+export class NumberSchema extends BaseSchema {
+    #constraints;
+    constructor(integer = false, constraints = {
+        maximum: undefined,
+        minimum: undefined,
+    }, description) {
+        super(false, description);
+        this.#constraints = { ...constraints, integer };
+    }
+    minimum(minimum) {
+        assertFiniteNumber(minimum, "minimum");
+        return new NumberSchema(this.#constraints.integer, {
+            maximum: this.#constraints.maximum,
+            minimum,
+        }, this.description);
+    }
+    maximum(maximum) {
+        assertFiniteNumber(maximum, "maximum");
+        return new NumberSchema(this.#constraints.integer, {
+            maximum,
+            minimum: this.#constraints.minimum,
+        }, this.description);
+    }
+    cloneWithDescription(description) {
+        return new NumberSchema(this.#constraints.integer, this.#constraints, description);
+    }
+    [schemaParser](value, path) {
+        const expected = this.#constraints.integer ? "integer" : "number";
+        if (typeof value !== "number" ||
+            !Number.isFinite(value) ||
+            (this.#constraints.integer && !Number.isInteger(value))) {
+            return { issues: [invalidTypeIssue(path, expected, value)] };
+        }
+        const issues = [];
+        const { maximum, minimum } = this.#constraints;
+        if (minimum !== undefined && value < minimum) {
+            issues.push(tooSmallIssue(path, `Number must be at least ${minimum}.`, minimum));
+        }
+        if (maximum !== undefined && value > maximum) {
+            issues.push(tooBigIssue(path, `Number must be at most ${maximum}.`, maximum));
+        }
+        return { value, issues };
+    }
+    [schemaJson]() {
+        const { integer, maximum, minimum } = this.#constraints;
+        return compactJsonSchema({
+            type: integer ? "integer" : "number",
+            minimum,
+            maximum,
+        });
+    }
+}
+export class BooleanSchema extends BaseSchema {
+    constructor(description) {
+        super(false, description);
+    }
+    cloneWithDescription(description) {
+        return new BooleanSchema(description);
+    }
+    [schemaParser](value, path) {
+        return typeof value === "boolean"
+            ? { value, issues: [] }
+            : { issues: [invalidTypeIssue(path, "boolean", value)] };
+    }
+    [schemaJson]() {
+        return { type: "boolean" };
+    }
+}
+export class NullSchema extends BaseSchema {
+    constructor(description) {
+        super(false, description);
+    }
+    cloneWithDescription(description) {
+        return new NullSchema(description);
+    }
+    [schemaParser](value, path) {
+        return value === null
+            ? { value, issues: [] }
+            : { issues: [invalidTypeIssue(path, "null", value)] };
+    }
+    [schemaJson]() {
+        return { type: "null" };
+    }
+}
+export class LiteralSchema extends BaseSchema {
+    #expected;
+    constructor(expected, description) {
+        super(false, description);
+        assertJsonPrimitive(expected, "literal");
+        this.#expected = expected;
+    }
+    cloneWithDescription(description) {
+        return new LiteralSchema(this.#expected, description);
+    }
+    [schemaParser](value, path) {
+        return value === this.#expected
+            ? { value: value, issues: [] }
+            : {
+                issues: [
+                    {
+                        code: "invalid_literal",
+                        path,
+                        message: `Expected literal ${JSON.stringify(this.#expected)}.`,
+                        expected: this.#expected,
+                        received: value,
+                    },
+                ],
+            };
+    }
+    [schemaJson]() {
+        return { const: normalizeJsonPrimitive(this.#expected) };
+    }
+}
+export class EnumSchema extends BaseSchema {
+    #values;
+    constructor(values, description) {
+        super(false, description);
+        if (values.length === 0) {
+            throw new TypeError("An enum schema requires at least one value.");
+        }
+        for (const value of values) {
+            assertJsonPrimitive(value, "enum value");
+        }
+        this.#values = Object.freeze([...values]);
+    }
+    cloneWithDescription(description) {
+        return new EnumSchema(this.#values, description);
+    }
+    [schemaParser](value, path) {
+        const matches = this.#values.some((candidate) => candidate === value);
+        return matches
+            ? { value: value, issues: [] }
+            : {
+                issues: [
+                    {
+                        code: "invalid_enum_value",
+                        path,
+                        message: "Value must match one of the enum values.",
+                        options: [...this.#values],
+                        received: value,
+                    },
+                ],
+            };
+    }
+    [schemaJson]() {
+        return {
+            enum: [...new Set(this.#values.map(normalizeJsonPrimitive))],
+        };
+    }
+}
+export class ArraySchema extends BaseSchema {
+    #item;
+    #constraints;
+    constructor(item, constraints = {
+        maximumItems: undefined,
+        minimumItems: undefined,
+    }, description) {
+        super(false, description);
+        this.#item = item;
+        this.#constraints = constraints;
+    }
+    minItems(minimumItems) {
+        assertNonNegativeInteger(minimumItems, "minimum item count");
+        return new ArraySchema(this.#item, {
+            ...this.#constraints,
+            minimumItems,
+        }, this.description);
+    }
+    maxItems(maximumItems) {
+        assertNonNegativeInteger(maximumItems, "maximum item count");
+        return new ArraySchema(this.#item, {
+            ...this.#constraints,
+            maximumItems,
+        }, this.description);
+    }
+    cloneWithDescription(description) {
+        return new ArraySchema(this.#item, this.#constraints, description);
+    }
+    [schemaParser](value, path) {
+        if (!Array.isArray(value)) {
+            return { issues: [invalidTypeIssue(path, "array", value)] };
+        }
+        const issues = [];
+        const { maximumItems, minimumItems } = this.#constraints;
+        if (minimumItems !== undefined && value.length < minimumItems) {
+            issues.push(tooSmallIssue(path, `Array must contain at least ${minimumItems} items.`, minimumItems));
+        }
+        if (maximumItems !== undefined && value.length > maximumItems) {
+            issues.push(tooBigIssue(path, `Array must contain at most ${maximumItems} items.`, maximumItems));
+        }
+        for (let index = 0; index < value.length; index += 1) {
+            if (!Object.hasOwn(value, index)) {
+                issues.push({
+                    code: "invalid_type",
+                    path: [...path, index],
+                    message: "Expected array item.",
+                    expected: "array item",
+                    received: "missing",
+                });
+                continue;
+            }
+            issues.push(...parseWithSchema(this.#item, value[index], [...path, index]).issues);
+        }
+        return { value: value, issues };
+    }
+    [schemaJson]() {
+        const { maximumItems, minimumItems } = this.#constraints;
+        return compactJsonSchema({
+            type: "array",
+            items: this.#item.toJSONSchema(),
+            minItems: minimumItems,
+            maxItems: maximumItems,
+        });
+    }
+}
+export class ObjectSchema extends BaseSchema {
+    #shape;
+    constructor(shape, description) {
+        super(false, description);
+        this.#shape = Object.freeze({ ...shape });
+    }
+    cloneWithDescription(description) {
+        return new ObjectSchema(this.#shape, description);
+    }
+    [schemaParser](value, path) {
+        if (!isPlainObject(value)) {
+            return { issues: [invalidTypeIssue(path, "object", value)] };
+        }
+        const issues = [];
+        for (const [key, propertySchema] of Object.entries(this.#shape)) {
+            const hasProperty = Object.hasOwn(value, key);
+            if (!hasProperty && propertySchema[schemaOptional]) {
+                continue;
+            }
+            if (hasProperty && value[key] === undefined) {
+                issues.push(invalidTypeIssue([...path, key], "JSON value", undefined));
+                continue;
+            }
+            issues.push(...parseWithSchema(propertySchema, value[key], [...path, key]).issues);
+        }
+        for (const key of Object.keys(value)) {
+            if (!Object.hasOwn(this.#shape, key)) {
+                issues.push({
+                    code: "unrecognized_key",
+                    path: [...path, key],
+                    message: `Unrecognized key "${key}".`,
+                    key,
+                });
+            }
+        }
+        return { value: value, issues };
+    }
+    [schemaJson]() {
+        const properties = Object.fromEntries(Object.entries(this.#shape).map(([key, propertySchema]) => [
+            key,
+            propertySchema.toJSONSchema(),
+        ]));
+        const required = Object.entries(this.#shape)
+            .filter(([, propertySchema]) => !propertySchema[schemaOptional])
+            .map(([key]) => key);
+        return {
+            type: "object",
+            properties,
+            required,
+            additionalProperties: false,
+        };
+    }
+}
+export class UnionSchema extends BaseSchema {
+    #schemas;
+    constructor(schemas, description) {
+        super(false, description);
+        if (schemas.length < 2) {
+            throw new TypeError("A union schema requires at least two alternatives.");
+        }
+        this.#schemas = Object.freeze([...schemas]);
+    }
+    cloneWithDescription(description) {
+        return new UnionSchema(this.#schemas, description);
+    }
+    [schemaParser](value, path) {
+        const alternatives = this.#schemas.map((candidate) => parseWithSchema(candidate, value, path));
+        const match = alternatives.find((candidate) => candidate.issues.length === 0);
+        if (match !== undefined) {
+            return { value: match.value, issues: [] };
+        }
+        return {
+            issues: [
+                {
+                    code: "invalid_union",
+                    path,
+                    message: "Value does not match any union alternative.",
+                    alternatives: alternatives.map((candidate) => candidate.issues),
+                },
+            ],
+        };
+    }
+    [schemaJson]() {
+        return { anyOf: this.#schemas.map((candidate) => candidate.toJSONSchema()) };
+    }
+}
+class OptionalSchema extends BaseSchema {
+    #inner;
+    constructor(inner, description) {
+        super(true, description);
+        this.#inner = inner;
+    }
+    cloneWithDescription(description) {
+        return new OptionalSchema(this.#inner, description);
+    }
+    [schemaParser](value, path) {
+        return value === undefined
+            ? { value: undefined, issues: [] }
+            : parseWithSchema(this.#inner, value, path);
+    }
+    [schemaJson]() {
+        return this.#inner.toJSONSchema();
+    }
+}
+class NullableSchema extends BaseSchema {
+    #inner;
+    constructor(inner, optional, description) {
+        super(optional, description);
+        this.#inner = inner;
+    }
+    cloneWithDescription(description) {
+        return new NullableSchema(this.#inner, this[schemaOptional], description);
+    }
+    [schemaParser](value, path) {
+        return value === null
+            ? { value: null, issues: [] }
+            : parseWithSchema(this.#inner, value, path);
+    }
+    [schemaJson]() {
+        return {
+            anyOf: [this.#inner.toJSONSchema(), { type: "null" }],
+        };
+    }
+}
+export const schema = Object.freeze({
+    array: (item) => new ArraySchema(item),
+    boolean: () => new BooleanSchema(),
+    enum: (values) => new EnumSchema(values),
+    integer: () => new NumberSchema(true),
+    literal: (value) => new LiteralSchema(value),
+    null: () => new NullSchema(),
+    number: () => new NumberSchema(),
+    object: (shape) => new ObjectSchema(shape),
+    string: () => new StringSchema(),
+    union: (schemas) => new UnionSchema(schemas),
+});
+function parseWithSchema(candidate, value, path) {
+    return candidate[schemaParser](value, path);
+}
+function invalidTypeIssue(path, expected, value) {
+    return {
+        code: "invalid_type",
+        path,
+        message: `Expected ${expected}.`,
+        expected,
+        received: value === null ? "null" : Array.isArray(value) ? "array" : typeof value,
+    };
+}
+function tooSmallIssue(path, message, minimum) {
+    return { code: "too_small", path, message, minimum };
+}
+function tooBigIssue(path, message, maximum) {
+    return { code: "too_big", path, message, maximum };
+}
+function compactJsonSchema(value) {
+    return Object.fromEntries(Object.entries(value).filter((entry) => {
+        return entry[1] !== undefined;
+    }));
+}
+function isPlainObject(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function assertNonNegativeInteger(value, name) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new TypeError(`The ${name} must be a non-negative integer.`);
+    }
+}
+function assertFiniteNumber(value, name) {
+    if (!Number.isFinite(value)) {
+        throw new TypeError(`The ${name} must be a finite number.`);
+    }
+}
+function assertJsonPrimitive(value, name) {
+    if (typeof value === "number" && !Number.isFinite(value)) {
+        throw new TypeError(`The ${name} must be a finite JSON number.`);
+    }
+}
+function normalizeJsonPrimitive(value) {
+    return (typeof value === "number" && Object.is(value, -0)
+        ? 0
+        : value);
+}

package/dist/standard-input.d.ts

@@ -0,0 +1 @@
+export declare function readStandardInput(): Promise<string>;

package/dist/standard-input.js

@@ -0,0 +1,7 @@
+export async function readStandardInput() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}

package/dist/type-utils.d.ts

@@ -0,0 +1 @@
+export type NoExtraKeys<TActual, TAllowed> = Exclude<keyof TActual, keyof TAllowed> extends never ? unknown : never;

package/dist/type-utils.js

@@ -0,0 +1 @@
+export {};

package/dist/workflow.d.ts

@@ -0,0 +1,160 @@
+import { type AutomationEventObserver } from "./events.js";
+import { type AccessPolicy, type ApprovalPolicy, type EnvironmentOverrides, type Harness } from "./harness.js";
+import type { JsonPrimitive as InternalJsonPrimitive, JsonValue as InternalJsonValue } from "./json.js";
+import type { InferSchema, Schema } from "./schema.js";
+import { type RunJournalMode } from "./run-journal.js";
+import type { NoExtraKeys } from "./type-utils.js";
+export type JsonPrimitive = InternalJsonPrimitive;
+export type JsonValue = InternalJsonValue;
+export type WorkflowResult = JsonValue | undefined;
+type MaybePromise<T> = PromiseLike<T> | T;
+type JsonCompatible<T> = T extends JsonPrimitive ? T : T extends (...arguments_: never[]) => unknown ? never : T extends readonly (infer TItem)[] ? readonly JsonCompatible<TItem>[] : T extends object ? {
+    readonly [TKey in keyof T]: JsonCompatible<T[TKey]>;
+} : never;
+type NormalizedWorkflowResult<TResult> = TResult extends void ? undefined : TResult;
+type JsonCompatibleWorkflowResult<TResult> = TResult extends undefined ? undefined : JsonCompatible<TResult>;
+type WorkflowResultConstraint<TResult> = [
+    NormalizedWorkflowResult<TResult>
+] extends [JsonCompatibleWorkflowResult<NormalizedWorkflowResult<TResult>>] ? unknown : never;
+declare const workflowDefinitionBrand: unique symbol;
+declare const workflowRunner: unique symbol;
+declare const workflowInputSchema: unique symbol;
+declare const workflowOutputSchema: unique symbol;
+declare const workflowHarness: unique symbol;
+type AnySchema = Schema<any, boolean>;
+export interface WorkflowContext<TInput> {
+    readonly input: TInput;
+    readonly signal: AbortSignal;
+    run<TOutputSchema extends AnySchema>(prompt: string, options: StructuredRunOptions<TOutputSchema>): Promise<InferSchema<TOutputSchema>>;
+    run(prompt: string, options: RunOptions): Promise<string>;
+    session(options?: SessionOptions): Session;
+}
+interface RunExecutionOptions {
+    readonly access: AccessPolicy;
+    readonly approval?: ApprovalPolicy;
+    readonly cwd?: string;
+    readonly env?: EnvironmentOverrides;
+    readonly harness?: Harness;
+    readonly name?: string;
+    readonly timeout?: number | false;
+}
+export interface RunOptions extends RunExecutionOptions {
+    readonly output?: never;
+}
+export interface StructuredRunOptions<TOutputSchema extends AnySchema> extends RunExecutionOptions {
+    readonly output: TOutputSchema;
+}
+type SessionRunExecutionOptions = Omit<RunExecutionOptions, "cwd" | "harness">;
+export interface SessionOptions {
+    readonly cwd?: string;
+    readonly env?: EnvironmentOverrides;
+    readonly harness?: Harness;
+    readonly name?: string;
+}
+export interface SessionRunOptions extends SessionRunExecutionOptions {
+    readonly output?: never;
+}
+export interface StructuredSessionRunOptions<TOutputSchema extends AnySchema> extends SessionRunExecutionOptions {
+    readonly output: TOutputSchema;
+}
+export interface Session {
+    run<TOutputSchema extends AnySchema>(prompt: string, options: StructuredSessionRunOptions<TOutputSchema>): Promise<InferSchema<TOutputSchema>>;
+    run(prompt: string, options: SessionRunOptions): Promise<string>;
+}
+export interface WorkflowDefinition<TResult, TInput = never, THasInput extends boolean = false> {
+    readonly [workflowDefinitionBrand]: true;
+    readonly [workflowRunner]: (context: WorkflowContext<TInput>) => MaybePromise<TResult>;
+    readonly [workflowInputSchema]: THasInput extends true ? Schema<TInput, boolean> : undefined;
+    readonly [workflowOutputSchema]: Schema<TResult, boolean> | undefined;
+    readonly [workflowHarness]: Harness | undefined;
+}
+type WorkflowDefinitionOptionsBase<TResult, TInput> = {
+    readonly harness?: Harness;
+    readonly output?: Schema<TResult, boolean>;
+    readonly run: (context: WorkflowContext<TInput>) => MaybePromise<TResult>;
+};
+export type WorkflowDefinitionOptions<TResult, TInput = never> = WorkflowDefinitionOptionsBase<TResult, TInput> & ([TInput] extends [never] ? {
+    readonly input?: never;
+} : {
+    readonly input: Schema<TInput, boolean>;
+});
+type InputAndOutputWorkflowOptions<TInputSchema extends AnySchema, TOutputSchema extends AnySchema> = {
+    readonly harness?: Harness;
+    readonly input: TInputSchema;
+    readonly output: TOutputSchema;
+    readonly run: (context: WorkflowContext<InferSchema<TInputSchema>>) => MaybePromise<InferSchema<TOutputSchema>>;
+};
+type InputWorkflowOptions<TInputSchema extends AnySchema, TResult> = {
+    readonly harness?: Harness;
+    readonly input: TInputSchema;
+    readonly output?: never;
+    readonly run: (context: WorkflowContext<InferSchema<TInputSchema>>) => MaybePromise<TResult>;
+} & WorkflowResultConstraint<TResult>;
+type AsyncJsonInputWorkflowOptions<TInputSchema extends AnySchema, TResult extends WorkflowResult | void> = {
+    readonly harness?: Harness;
+    readonly input: TInputSchema;
+    readonly output?: never;
+    readonly run: (context: WorkflowContext<InferSchema<TInputSchema>>) => PromiseLike<TResult>;
+};
+type OutputWorkflowOptions<TOutputSchema extends AnySchema> = {
+    readonly harness?: Harness;
+    readonly input?: never;
+    readonly output: TOutputSchema;
+    readonly run: (context: WorkflowContext<never>) => MaybePromise<InferSchema<TOutputSchema>>;
+};
+type InferredWorkflowOptions<TResult> = {
+    readonly harness?: Harness;
+    readonly input?: never;
+    readonly output?: never;
+    readonly run: (context: WorkflowContext<never>) => MaybePromise<TResult>;
+} & WorkflowResultConstraint<TResult>;
+type AsyncJsonWorkflowOptions<TResult extends WorkflowResult | void> = {
+    readonly harness?: Harness;
+    readonly input?: never;
+    readonly output?: never;
+    readonly run: (context: WorkflowContext<never>) => PromiseLike<TResult>;
+};
+type HasDeclaredOutput<TOptions> = TOptions extends {
+    readonly output: AnySchema;
+} ? true : false;
+type ReusableWorkflowOptionsShape = {
+    readonly harness?: Harness;
+    readonly input?: Schema<any, boolean>;
+    readonly output?: Schema<any, boolean>;
+    readonly run: (...arguments_: never[]) => unknown;
+};
+type UnwrapMaybePromise<TValue> = TValue extends PromiseLike<infer TAwaited> ? TAwaited : TValue;
+type ReusableWorkflowResult<TOptions extends ReusableWorkflowOptionsShape> = UnwrapMaybePromise<ReturnType<TOptions["run"]>>;
+type ReusableWorkflowInput<TOptions extends ReusableWorkflowOptionsShape> = TOptions extends {
+    readonly input: Schema<infer TInput, boolean>;
+} ? TInput : never;
+export declare function defineWorkflow<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, const TOptions extends InputAndOutputWorkflowOptions<TInputSchema, TOutputSchema>>(options: TOptions & InputAndOutputWorkflowOptions<TInputSchema, TOutputSchema> & NoExtraKeys<TOptions, InputAndOutputWorkflowOptions<TInputSchema, TOutputSchema>>): WorkflowDefinition<InferSchema<TOutputSchema>, InferSchema<TInputSchema>, true>;
+export declare function defineWorkflow<TInputSchema extends AnySchema, TResult extends WorkflowResult | void, const TOptions extends AsyncJsonInputWorkflowOptions<TInputSchema, TResult>>(options: TOptions & AsyncJsonInputWorkflowOptions<TInputSchema, TResult> & NoExtraKeys<TOptions, AsyncJsonInputWorkflowOptions<TInputSchema, TResult>>): WorkflowDefinition<NormalizedWorkflowResult<TResult>, InferSchema<TInputSchema>, true>;
+export declare function defineWorkflow<TInputSchema extends AnySchema, TResult, const TOptions extends InputWorkflowOptions<TInputSchema, TResult>>(options: TOptions & InputWorkflowOptions<TInputSchema, TResult> & NoExtraKeys<TOptions, InputWorkflowOptions<TInputSchema, TResult>>): WorkflowDefinition<NormalizedWorkflowResult<TResult>, InferSchema<TInputSchema>, true>;
+export declare function defineWorkflow<TOutputSchema extends AnySchema, const TOptions extends OutputWorkflowOptions<TOutputSchema>>(options: TOptions & OutputWorkflowOptions<TOutputSchema> & NoExtraKeys<TOptions, OutputWorkflowOptions<TOutputSchema>>): WorkflowDefinition<InferSchema<TOutputSchema>>;
+export declare function defineWorkflow<TResult extends WorkflowResult | void, const TOptions extends AsyncJsonWorkflowOptions<TResult>>(options: TOptions & AsyncJsonWorkflowOptions<TResult> & NoExtraKeys<TOptions, AsyncJsonWorkflowOptions<TResult>>): WorkflowDefinition<NormalizedWorkflowResult<TResult>>;
+export declare function defineWorkflow<TResult, const TOptions extends InferredWorkflowOptions<TResult>>(options: TOptions & InferredWorkflowOptions<TResult> & NoExtraKeys<TOptions, InferredWorkflowOptions<TResult>>): WorkflowDefinition<NormalizedWorkflowResult<TResult>>;
+export declare function defineWorkflow<const TOptions extends ReusableWorkflowOptionsShape>(options: TOptions & WorkflowResultConstraint<ReusableWorkflowResult<TOptions>> & (HasDeclaredOutput<TOptions> extends true ? never : unknown) & NoExtraKeys<TOptions, ReusableWorkflowOptionsShape>): WorkflowDefinition<NormalizedWorkflowResult<ReusableWorkflowResult<TOptions>>, ReusableWorkflowInput<TOptions>, [
+    ReusableWorkflowInput<TOptions>
+] extends [never] ? false : true>;
+export declare function isWorkflowDefinition(value: unknown): value is WorkflowDefinition<unknown, unknown, boolean>;
+export interface ExecuteWorkflowOptions<TInput> {
+    readonly concurrency?: number;
+    readonly input: TInput;
+    readonly onEvent?: AutomationEventObserver;
+    readonly record?: RunJournalMode | false;
+    readonly signal?: AbortSignal;
+    readonly workspaceRoot?: string;
+}
+export interface ExecuteWorkflowWithoutInputOptions {
+    readonly concurrency?: number;
+    readonly input?: never;
+    readonly onEvent?: AutomationEventObserver;
+    readonly record?: RunJournalMode | false;
+    readonly signal?: AbortSignal;
+    readonly workspaceRoot?: string;
+}
+export declare function executeWorkflow<TResult, TInput>(definition: WorkflowDefinition<TResult, TInput, true>, options: ExecuteWorkflowOptions<TInput>): Promise<TResult>;
+export declare function executeWorkflow<TResult>(definition: WorkflowDefinition<TResult, never, false>, options?: ExecuteWorkflowWithoutInputOptions): Promise<TResult>;
+export declare function executeWorkflowWithControls(definition: any, options?: any, forceSignal?: AbortSignal): Promise<any>;
+export {};