@xfey/tutti 0.1.0

package/dist/providers/openai/provider-config.js

@@ -0,0 +1,117 @@
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+import { openAiCredentialExists, } from "./credential-store.js";
+import { readTextFile, writePrivateTextFile } from "./machine-local-files.js";
+import { OpenAiProviderConfigError } from "./provider-config-errors.js";
+import { parseOpenAiProviderConfig } from "./provider-config-shape.js";
+import { formatProjectOpenAiProviderConfig, parseTomlOpenAiSection, parseTuttiConfigToml, } from "./provider-config-toml.js";
+export { OpenAiProviderConfigError } from "./provider-config-errors.js";
+export { parseOpenAiProviderConfig, } from "./provider-config-shape.js";
+export function resolveTuttiHome(input, cwd = process.cwd()) {
+    if (input === undefined || input.trim() === "") {
+        return join(homedir(), ".tutti");
+    }
+    const trimmed = input.trim();
+    if (trimmed === "~") {
+        return homedir();
+    }
+    if (trimmed.startsWith("~/")) {
+        return join(homedir(), trimmed.slice(2));
+    }
+    return isAbsolute(trimmed) ? resolve(trimmed) : resolve(cwd, trimmed);
+}
+export function getProjectProviderConfigPath(tuttiHome, projectId) {
+    return join(tuttiHome, "projects", projectId, "config.toml");
+}
+export function readProjectOpenAiProviderConfig(tuttiHome, projectId) {
+    const sourcePath = getProjectProviderConfigPath(tuttiHome, projectId);
+    const readResult = readTextFile(sourcePath);
+    if (readResult.kind === "missing") {
+        return { kind: "missing", source_path: sourcePath };
+    }
+    try {
+        return {
+            kind: "ok",
+            source_path: sourcePath,
+            config: parseOpenAiProviderConfig(parseTomlOpenAiSection({
+                document: parseTuttiConfigToml(readResult.value),
+            })),
+        };
+    }
+    catch (error) {
+        if (error instanceof OpenAiProviderConfigError) {
+            return { kind: "invalid", source_path: sourcePath, error };
+        }
+        throw error;
+    }
+}
+export function resolveOpenAiProviderConfig(options) {
+    const credentialExists = options.credentialExists ?? openAiCredentialExists;
+    const projectConfig = readProjectOpenAiProviderConfig(options.tuttiHome, options.projectId);
+    if (projectConfig.kind === "invalid") {
+        return {
+            kind: "unavailable",
+            reason: "project_config_invalid",
+            source_path: projectConfig.source_path,
+            error: projectConfig.error,
+        };
+    }
+    if (projectConfig.kind === "ok") {
+        if (!credentialExists(options.tuttiHome, options.projectId, projectConfig.config.credential_ref)) {
+            return {
+                kind: "unavailable",
+                reason: "project_credential_missing",
+                source_path: projectConfig.source_path,
+            };
+        }
+        return {
+            kind: "project_config",
+            source_path: projectConfig.source_path,
+            config: projectConfig.config,
+        };
+    }
+    return {
+        kind: "unavailable",
+        reason: "project_config_missing",
+        source_path: projectConfig.source_path,
+    };
+}
+export function writeProjectOpenAiProviderConfig(tuttiHome, projectId, config) {
+    writePrivateTextFile(getProjectProviderConfigPath(tuttiHome, projectId), formatProjectOpenAiProviderConfig(config));
+}
+export function createRedactedOpenAiProviderConfigProjection(config) {
+    const projection = {
+        status: "configured",
+        provider: config.provider,
+        auth_kind: config.auth_kind,
+        redacted_key: config.redacted_key,
+        default_model: config.default_model,
+        validated_at: config.validated_at,
+    };
+    return projection;
+}
+export function readOpenAiProviderConfigProjection(options) {
+    const resolution = resolveOpenAiProviderConfig(options);
+    if (resolution.kind === "project_config") {
+        return createRedactedOpenAiProviderConfigProjection(resolution.config);
+    }
+    if (resolution.reason === "project_config_missing") {
+        return { status: "not_configured" };
+    }
+    const projection = {
+        status: "invalid",
+        invalid_reason_code: "unknown",
+    };
+    if (resolution.reason === "project_credential_missing") {
+        const config = readProjectOpenAiProviderConfig(options.tuttiHome, options.projectId);
+        if (config.kind === "ok") {
+            projection.provider = config.config.provider;
+            projection.auth_kind = config.config.auth_kind;
+            projection.redacted_key = config.config.redacted_key;
+            projection.default_model = config.config.default_model;
+            projection.validated_at = config.config.validated_at;
+        }
+    }
+    return projection;
+}
+//# sourceMappingURL=provider-config.js.map

package/dist/providers/openai/provider-setup.d.ts

@@ -0,0 +1,31 @@
+import type { ProjectId } from "@tutti/shared/ids";
+import { type OpenAiCredentialRef } from "./credential-store.js";
+import { type OpenAiCredentialValidationDiagnostic, type OpenAiCredentialValidationInput, type OpenAiCredentialValidationResult } from "./credential-validation.js";
+import { type OpenAiProviderConfig, type RedactedOpenAiProviderConfigProjection } from "./provider-config.js";
+export type ProjectOpenAiProviderSetupInput = {
+    apiKey: string;
+    apiBaseUrl?: string;
+    defaultModel?: string;
+};
+export type OpenAiProviderCredentialValidator = (input: OpenAiCredentialValidationInput) => Promise<OpenAiCredentialValidationResult>;
+export type ConfigureProjectOpenAiProviderOptions = ProjectOpenAiProviderSetupInput & {
+    tuttiHome: string;
+    projectId: ProjectId;
+    validateCredential?: OpenAiProviderCredentialValidator;
+    createCredentialRef?: () => OpenAiCredentialRef;
+    now?: () => Date;
+};
+export type ConfigureProjectOpenAiProviderResult = {
+    kind: "configured";
+    config: OpenAiProviderConfig;
+    projection: RedactedOpenAiProviderConfigProjection;
+} | {
+    kind: "validation_failed";
+    reason: Exclude<OpenAiCredentialValidationResult, {
+        kind: "ok";
+    }>["reason"] | "provider_auth_invalid";
+    retryable: boolean;
+    diagnostic?: OpenAiCredentialValidationDiagnostic;
+};
+export declare function configureProjectOpenAiProvider(options: ConfigureProjectOpenAiProviderOptions): Promise<ConfigureProjectOpenAiProviderResult>;
+//# sourceMappingURL=provider-setup.d.ts.map

package/dist/providers/openai/provider-setup.js

@@ -0,0 +1,88 @@
+import { createOpenAiCredentialRef, createRedactedOpenAiApiKeyLabel, isOpenAiApiKey, writeOpenAiApiKeyCredential, } from "./credential-store.js";
+import { validateOpenAiCredential, } from "./credential-validation.js";
+import { DEFAULT_OPENAI_MODEL, OPENAI_API_KEY_AUTH_KIND, OPENAI_PROVIDER } from "./model-config.js";
+import { createRedactedOpenAiProviderConfigProjection, writeProjectOpenAiProviderConfig, } from "./provider-config.js";
+function trimOptional(value) {
+    const trimmed = value?.trim();
+    return trimmed === undefined || trimmed === "" ? undefined : trimmed;
+}
+function validateApiBaseUrl(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    try {
+        const url = new URL(value);
+        if (url.protocol === "http:" || url.protocol === "https:") {
+            return value;
+        }
+    }
+    catch {
+        // Fall through to the same validation result used for malformed URLs.
+    }
+    return undefined;
+}
+function validationInput(options) {
+    const input = {
+        apiKey: options.apiKey.trim(),
+        defaultModel: trimOptional(options.defaultModel) ?? DEFAULT_OPENAI_MODEL,
+    };
+    const apiBaseUrl = validateApiBaseUrl(trimOptional(options.apiBaseUrl));
+    if (apiBaseUrl !== undefined) {
+        input.apiBaseUrl = apiBaseUrl;
+    }
+    return input;
+}
+export async function configureProjectOpenAiProvider(options) {
+    const apiKey = options.apiKey.trim();
+    if (!isOpenAiApiKey(apiKey)) {
+        return {
+            kind: "validation_failed",
+            reason: "provider_auth_invalid",
+            retryable: false,
+        };
+    }
+    const apiBaseUrl = trimOptional(options.apiBaseUrl);
+    if (apiBaseUrl !== undefined && validateApiBaseUrl(apiBaseUrl) === undefined) {
+        return {
+            kind: "validation_failed",
+            reason: "provider_network_error",
+            retryable: false,
+        };
+    }
+    const validator = options.validateCredential ?? validateOpenAiCredential;
+    const validation = await validator(validationInput(options));
+    if (validation.kind === "failed") {
+        return {
+            kind: "validation_failed",
+            reason: validation.reason,
+            retryable: validation.retryable,
+            ...(validation.diagnostic === undefined ? {} : { diagnostic: validation.diagnostic }),
+        };
+    }
+    const credentialRef = (options.createCredentialRef ?? createOpenAiCredentialRef)();
+    writeOpenAiApiKeyCredential({
+        tuttiHome: options.tuttiHome,
+        projectId: options.projectId,
+        credentialRef,
+        apiKey,
+        ...(options.now === undefined ? {} : { now: options.now }),
+    });
+    const config = {
+        provider: OPENAI_PROVIDER,
+        auth_kind: OPENAI_API_KEY_AUTH_KIND,
+        credential_ref: credentialRef,
+        redacted_key: createRedactedOpenAiApiKeyLabel(apiKey),
+        default_model: validation.default_model,
+        validated_at: validation.validated_at,
+    };
+    if (apiBaseUrl !== undefined) {
+        config.api_base_url = apiBaseUrl;
+    }
+    writeProjectOpenAiProviderConfig(options.tuttiHome, options.projectId, config);
+    return {
+        kind: "configured",
+        config,
+        projection: createRedactedOpenAiProviderConfigProjection(config),
+    };
+}
+//# sourceMappingURL=provider-setup.js.map

package/dist/providers/openai/sdk-procedure-runner.d.ts

@@ -0,0 +1,70 @@
+import { type OpenAiCredentialValidationDiagnostic, type OpenAiCredentialValidationFailureReason } from "./credential-validation.js";
+import { type OpenAiTokenUsage } from "./token-usage.js";
+export type OpenAiJsonSchema = {
+    [key: string]: unknown;
+};
+export type OpenAiStructuredOutputClient = {
+    responses: {
+        create: (body: {
+            model: string;
+            input: string;
+            instructions?: string;
+            max_output_tokens: number;
+            store: false;
+            text: {
+                format: {
+                    type: "json_schema";
+                    name: string;
+                    schema: OpenAiJsonSchema;
+                    description?: string;
+                    strict: true;
+                };
+            };
+        }, options?: {
+            timeout?: number;
+            maxRetries?: number;
+        }) => Promise<unknown>;
+    };
+};
+export type OpenAiStructuredOutputClientInput = {
+    apiKey: string;
+    apiBaseUrl?: string;
+    organizationId?: string;
+    openAiProjectId?: string;
+};
+export type OpenAiStructuredOutputFailureReason = OpenAiCredentialValidationFailureReason | "provider_invalid_response";
+export type OpenAiStructuredOutputInvalidResponseKind = "missing_output_text" | "empty_output_text" | "malformed_json" | "schema_invalid";
+export type OpenAiStructuredOutputErrorDetails = {
+    reason: OpenAiStructuredOutputFailureReason;
+    retryable: boolean;
+    invalid_response_kind?: OpenAiStructuredOutputInvalidResponseKind;
+    provider_diagnostic?: OpenAiCredentialValidationDiagnostic;
+};
+export type RunOpenAiStructuredOutputOptions<TOutput> = {
+    client?: OpenAiStructuredOutputClient;
+    model: string;
+    instructions: string;
+    input: string;
+    schemaName: string;
+    schemaDescription?: string;
+    schema: OpenAiJsonSchema;
+    maxOutputTokens?: number;
+    maxAttempts?: number;
+    timeoutMs?: number;
+    validate?: (value: unknown) => value is TOutput;
+};
+export type OpenAiStructuredOutputResult<TOutput> = {
+    output: TOutput;
+    raw_text: string;
+    usage?: OpenAiTokenUsage;
+};
+export declare class OpenAiStructuredOutputError extends Error {
+    readonly reason: OpenAiStructuredOutputFailureReason;
+    readonly retryable: boolean;
+    readonly invalidResponseKind?: OpenAiStructuredOutputInvalidResponseKind | undefined;
+    readonly details: OpenAiStructuredOutputErrorDetails;
+    constructor(reason: OpenAiStructuredOutputFailureReason, retryable: boolean, message: string, invalidResponseKind?: OpenAiStructuredOutputInvalidResponseKind | undefined, providerDiagnostic?: OpenAiCredentialValidationDiagnostic);
+}
+export declare function createOpenAiStructuredOutputClient(input: OpenAiStructuredOutputClientInput): OpenAiStructuredOutputClient;
+export declare function runOpenAiStructuredOutput<TOutput>(options: RunOpenAiStructuredOutputOptions<TOutput>): Promise<OpenAiStructuredOutputResult<TOutput>>;
+//# sourceMappingURL=sdk-procedure-runner.d.ts.map

package/dist/providers/openai/sdk-procedure-runner.js

@@ -0,0 +1,123 @@
+import OpenAI from "openai";
+import { classifyOpenAiCredentialValidationError, isOpenAiCredentialValidationFailureRetryable, summarizeOpenAiCredentialValidationError, } from "./credential-validation.js";
+import { extractOpenAiResponseTokenUsage } from "./token-usage.js";
+export class OpenAiStructuredOutputError extends Error {
+    reason;
+    retryable;
+    invalidResponseKind;
+    details;
+    constructor(reason, retryable, message, invalidResponseKind, providerDiagnostic) {
+        super(message);
+        this.reason = reason;
+        this.retryable = retryable;
+        this.invalidResponseKind = invalidResponseKind;
+        this.name = "OpenAiStructuredOutputError";
+        this.details = {
+            reason,
+            retryable,
+            ...(invalidResponseKind === undefined ? {} : { invalid_response_kind: invalidResponseKind }),
+            ...(providerDiagnostic === undefined ? {} : { provider_diagnostic: providerDiagnostic }),
+        };
+    }
+}
+const DEFAULT_OUTPUT_TOKENS = 4096;
+const DEFAULT_TIMEOUT_MS = 120_000;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function createOpenAiStructuredOutputClient(input) {
+    const clientOptions = {
+        apiKey: input.apiKey,
+        maxRetries: 0,
+        timeout: DEFAULT_TIMEOUT_MS,
+    };
+    if (input.apiBaseUrl !== undefined) {
+        clientOptions.baseURL = input.apiBaseUrl;
+    }
+    if (input.organizationId !== undefined) {
+        clientOptions.organization = input.organizationId;
+    }
+    if (input.openAiProjectId !== undefined) {
+        clientOptions.project = input.openAiProjectId;
+    }
+    return new OpenAI(clientOptions);
+}
+function extractOutputText(response) {
+    if (!isRecord(response) || typeof response.output_text !== "string") {
+        throw new OpenAiStructuredOutputError("provider_invalid_response", true, "OpenAI structured output response did not include output_text", "missing_output_text");
+    }
+    const outputText = response.output_text.trim();
+    if (outputText.length === 0) {
+        throw new OpenAiStructuredOutputError("provider_invalid_response", true, "OpenAI structured output response was empty", "empty_output_text");
+    }
+    return outputText;
+}
+function parseOutputJson(rawText) {
+    try {
+        return JSON.parse(rawText);
+    }
+    catch {
+        throw new OpenAiStructuredOutputError("provider_invalid_response", true, "OpenAI structured output response was not valid JSON", "malformed_json");
+    }
+}
+function shouldRetryStructuredOutputError(error) {
+    return (error.reason === "provider_invalid_response" &&
+        (error.invalidResponseKind === "missing_output_text" ||
+            error.invalidResponseKind === "empty_output_text"));
+}
+export async function runOpenAiStructuredOutput(options) {
+    const client = options.client;
+    if (client === undefined) {
+        throw new OpenAiStructuredOutputError("provider_invalid_response", false, "OpenAI structured output client was not configured");
+    }
+    const maxAttempts = Math.max(1, Math.floor(options.maxAttempts ?? 2));
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        try {
+            const response = await client.responses.create({
+                model: options.model,
+                input: options.input,
+                instructions: options.instructions,
+                max_output_tokens: options.maxOutputTokens ?? DEFAULT_OUTPUT_TOKENS,
+                store: false,
+                text: {
+                    format: {
+                        type: "json_schema",
+                        name: options.schemaName,
+                        schema: options.schema,
+                        ...(options.schemaDescription === undefined
+                            ? {}
+                            : { description: options.schemaDescription }),
+                        strict: true,
+                    },
+                },
+            }, {
+                timeout: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+                maxRetries: 0,
+            });
+            const rawText = extractOutputText(response);
+            const parsed = parseOutputJson(rawText);
+            if (options.validate !== undefined && !options.validate(parsed)) {
+                throw new OpenAiStructuredOutputError("provider_invalid_response", true, "OpenAI structured output response failed local schema validation", "schema_invalid");
+            }
+            const usage = extractOpenAiResponseTokenUsage(response);
+            return {
+                output: parsed,
+                raw_text: rawText,
+                ...(usage === undefined ? {} : { usage }),
+            };
+        }
+        catch (error) {
+            if (error instanceof OpenAiStructuredOutputError) {
+                if (attempt < maxAttempts && shouldRetryStructuredOutputError(error)) {
+                    continue;
+                }
+                throw error;
+            }
+            const reason = classifyOpenAiCredentialValidationError(error);
+            const retryable = isOpenAiCredentialValidationFailureRetryable(reason);
+            throw new OpenAiStructuredOutputError(reason, retryable, "OpenAI structured output request failed", undefined, summarizeOpenAiCredentialValidationError(error, reason));
+        }
+    }
+    throw new OpenAiStructuredOutputError("provider_invalid_response", true, "OpenAI structured output response was empty", "empty_output_text");
+}
+//# sourceMappingURL=sdk-procedure-runner.js.map

package/dist/providers/openai/token-usage.d.ts

@@ -0,0 +1,11 @@
+import type { CodexAppServerJsonRpcNotification } from "./app-server/json-rpc.js";
+export type OpenAiTokenUsage = {
+    input_tokens: number;
+    cached_input_tokens: number;
+    output_tokens: number;
+    reasoning_output_tokens: number;
+    total_tokens: number;
+};
+export declare function extractOpenAiResponseTokenUsage(response: unknown): OpenAiTokenUsage | undefined;
+export declare function extractCodexAppServerTokenUsage(notifications: readonly CodexAppServerJsonRpcNotification[]): OpenAiTokenUsage | undefined;
+//# sourceMappingURL=token-usage.d.ts.map

package/dist/providers/openai/token-usage.js

@@ -0,0 +1,90 @@
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readInteger(record, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "number" && Number.isInteger(value) && value >= 0) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function readNestedInteger(record, parentKey, ...keys) {
+    const nested = record[parentKey];
+    return isRecord(nested) ? readInteger(nested, ...keys) : undefined;
+}
+function fromPartialUsage(input) {
+    const inputTokens = input.inputTokens ?? 0;
+    const cachedInputTokens = input.cachedInputTokens ?? 0;
+    const outputTokens = input.outputTokens ?? 0;
+    const reasoningOutputTokens = input.reasoningOutputTokens ?? 0;
+    const totalTokens = input.totalTokens ?? inputTokens + outputTokens;
+    if (totalTokens <= 0) {
+        return undefined;
+    }
+    return {
+        input_tokens: inputTokens,
+        cached_input_tokens: cachedInputTokens,
+        output_tokens: outputTokens,
+        reasoning_output_tokens: reasoningOutputTokens,
+        total_tokens: totalTokens,
+    };
+}
+export function extractOpenAiResponseTokenUsage(response) {
+    if (!isRecord(response) || !isRecord(response.usage)) {
+        return undefined;
+    }
+    const inputTokens = readInteger(response.usage, "input_tokens", "inputTokens");
+    const cachedInputTokens = readNestedInteger(response.usage, "input_tokens_details", "cached_tokens", "cachedTokens") ??
+        readNestedInteger(response.usage, "inputTokensDetails", "cached_tokens", "cachedTokens");
+    const outputTokens = readInteger(response.usage, "output_tokens", "outputTokens");
+    const reasoningOutputTokens = readNestedInteger(response.usage, "output_tokens_details", "reasoning_tokens", "reasoningTokens") ??
+        readNestedInteger(response.usage, "outputTokensDetails", "reasoning_tokens", "reasoningTokens");
+    const totalTokens = readInteger(response.usage, "total_tokens", "totalTokens");
+    return fromPartialUsage({
+        ...(inputTokens === undefined ? {} : { inputTokens }),
+        ...(cachedInputTokens === undefined ? {} : { cachedInputTokens }),
+        ...(outputTokens === undefined ? {} : { outputTokens }),
+        ...(reasoningOutputTokens === undefined ? {} : { reasoningOutputTokens }),
+        ...(totalTokens === undefined ? {} : { totalTokens }),
+    });
+}
+function tokenUsageFromCodexParams(params) {
+    if (!isRecord(params) || !isRecord(params.tokenUsage)) {
+        return undefined;
+    }
+    const total = isRecord(params.tokenUsage.total)
+        ? params.tokenUsage.total
+        : isRecord(params.tokenUsage.last)
+            ? params.tokenUsage.last
+            : undefined;
+    if (total === undefined) {
+        return undefined;
+    }
+    const inputTokens = readInteger(total, "inputTokens", "input_tokens");
+    const cachedInputTokens = readInteger(total, "cachedInputTokens", "cached_input_tokens");
+    const outputTokens = readInteger(total, "outputTokens", "output_tokens");
+    const reasoningOutputTokens = readInteger(total, "reasoningOutputTokens", "reasoning_output_tokens");
+    const totalTokens = readInteger(total, "totalTokens", "total_tokens");
+    return fromPartialUsage({
+        ...(inputTokens === undefined ? {} : { inputTokens }),
+        ...(cachedInputTokens === undefined ? {} : { cachedInputTokens }),
+        ...(outputTokens === undefined ? {} : { outputTokens }),
+        ...(reasoningOutputTokens === undefined ? {} : { reasoningOutputTokens }),
+        ...(totalTokens === undefined ? {} : { totalTokens }),
+    });
+}
+export function extractCodexAppServerTokenUsage(notifications) {
+    for (const notification of notifications.toReversed()) {
+        if (notification.method !== "thread/tokenUsage/updated") {
+            continue;
+        }
+        const usage = tokenUsageFromCodexParams(notification.params);
+        if (usage !== undefined) {
+            return usage;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=token-usage.js.map

package/dist/run-engine/index.d.ts

@@ -0,0 +1,61 @@
+import { type ActivityRef, type TaskId } from "@tutti/shared/ids";
+import type { RunLineage } from "@tutti/shared/domain";
+import type { ActivityProjection, ExecutionStatusProjection, TaskProjection } from "@tutti/shared/schemas/api";
+export type RunTerminalConclusion = {
+    kind: "completed";
+    summary: string;
+} | {
+    kind: "needs_human";
+    summary: string;
+} | {
+    kind: "failed";
+    summary: string;
+};
+export type RunExecutionContext = {
+    activity_ref: ActivityRef;
+    task_id: TaskId;
+    run_lineage: RunLineage;
+    reportProgress: (progress: RunProgressUpdate) => void;
+};
+export type RunProgressUpdate = {
+    summary: string;
+    phase?: string;
+};
+export type StartRunOptions = {
+    activity_ref?: ActivityRef;
+    task: TaskProjection;
+    run_lineage: RunLineage;
+    title: string;
+    summary: string;
+    now?: () => Date;
+    execute: (context: RunExecutionContext) => Promise<RunTerminalConclusion>;
+    onTransition?: (state: RunEngineState) => void;
+};
+export type StartRunResult = {
+    kind: "accepted";
+    activity: ActivityProjection;
+} | {
+    kind: "already_running";
+    activity_ref: ActivityRef;
+};
+export type RunEngineState = {
+    activity: ActivityProjection;
+    execution_status: ExecutionStatusProjection;
+    transition_kind: "started" | "progress" | "terminal";
+    progress?: RunProgressUpdate;
+};
+export declare class RunEngine {
+    private active;
+    private lastConclusion;
+    private readonly now;
+    constructor(options?: {
+        now?: () => Date;
+    });
+    startRun(options: StartRunOptions): StartRunResult;
+    getExecutionStatus(): ExecutionStatusProjection;
+    waitForIdle(): Promise<void>;
+    private state;
+    private updateActiveProgress;
+    private finishActive;
+}
+//# sourceMappingURL=index.d.ts.map