@ekairos/tasks 1.22.35

package/dist/index.js

@@ -0,0 +1,5 @@
+export { tasksDomain } from "./domain.js";
+export { createApprovalOutcome, approvalOutcomeForCommand, approvalOutcomeSchema, } from "./approval.js";
+export { parseTaskOutcome, taskOutcomeToken, toStoredOutcomeSchema, } from "./task.js";
+export { Task, } from "./service.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,EACL,qBAAqB,EACrB,yBAAyB,EACzB,qBAAqB,GAGtB,MAAM,eAAe,CAAA;AACtB,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,qBAAqB,GAOtB,MAAM,WAAW,CAAA;AAClB,OAAO,EACL,IAAI,GAOL,MAAM,cAAc,CAAA"}

package/dist/service.d.ts

@@ -0,0 +1,111 @@
+import { type TaskData, type TaskHandle, type TaskOutcomeSchema, type TaskStoredOutcomeSchema } from "./task.js";
+export type ServiceResult<T = unknown> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: string;
+    issues?: unknown;
+};
+export type TasksRuntime = {
+    db: any;
+};
+export type TasksClientRuntime = {
+    use(domain: unknown): Promise<any>;
+};
+export type TaskRecord<TContext = unknown, TOutcome = unknown> = TaskData<TContext, TOutcome> & {
+    errorText?: string;
+};
+export type TaskOpenActionInput = {
+    id?: string;
+    kind: string;
+    key: string;
+    instructions: string;
+    context?: unknown;
+    outcomeKind?: string;
+    outcomeSchema: TaskStoredOutcomeSchema;
+};
+export type TaskDecideActionInput = {
+    id: string;
+    outcome: unknown;
+    resumeWorkflow?: boolean;
+    runId?: string;
+};
+export type TaskCancelActionInput = {
+    id: string;
+    reason?: string;
+    runId?: string;
+};
+export type TaskFailActionInput = {
+    id: string;
+    errorText: string;
+    runId?: string;
+};
+export type TaskStartActionInput = {
+    id: string;
+    runId: string;
+};
+export type TaskReleaseActionInput = {
+    id: string;
+    runId: string;
+    actor?: unknown;
+    comment?: string;
+};
+export type TaskGetActionInput = {
+    id: string;
+};
+export type TaskAwaitOutcomeActionInput = {
+    id: string;
+};
+export type TaskOpenOptions = {
+    id?: string;
+    outcomeKind?: string;
+};
+export type TaskOpenInput<TOutcome, TContext = unknown> = {
+    id?: string;
+    kind: string;
+    key: string;
+    outcome: TaskOutcomeSchema<TOutcome>;
+    instructions: string;
+    context: TContext;
+    outcomeKind?: string;
+};
+export type TaskApprovalInput<TContext = unknown> = {
+    id?: string;
+    key: string;
+    instructions: string;
+    context: TContext;
+};
+export declare class TaskService {
+    private readonly runtime;
+    constructor(runtime: TasksRuntime);
+    private db;
+    private getTaskRecord;
+    openRaw(input: TaskOpenActionInput): Promise<ServiceResult<TaskRecord>>;
+    decide(input: TaskDecideActionInput): Promise<ServiceResult<TaskRecord>>;
+    cancel(input: TaskCancelActionInput): Promise<ServiceResult<TaskRecord>>;
+    fail(input: TaskFailActionInput): Promise<ServiceResult<TaskRecord>>;
+    getRaw(input: TaskGetActionInput): Promise<ServiceResult<TaskRecord>>;
+    awaitOutcome(input: TaskAwaitOutcomeActionInput): Promise<ServiceResult<unknown>>;
+    start(input: TaskStartActionInput): Promise<ServiceResult<TaskRecord>>;
+    release(input: TaskReleaseActionInput): Promise<ServiceResult<TaskRecord>>;
+}
+export declare class Task {
+    static create<TOutcome, TContext = unknown>(runtime: TasksClientRuntime, input: TaskOpenInput<TOutcome, TContext>): Promise<TaskHandle<TOutcome, TContext>>;
+    static open<TOutcome, TContext = unknown>(runtime: TasksClientRuntime, input: TaskOpenInput<TOutcome, TContext>): Promise<TaskHandle<TOutcome, TContext>>;
+    static approval<TContext = unknown>(runtime: TasksClientRuntime, input: TaskApprovalInput<TContext>): Promise<TaskHandle<{
+        outcome: "approved";
+        approved: true;
+        decidedBy?: string | undefined;
+        decidedAt?: string | undefined;
+        note?: string | undefined;
+    } | {
+        outcome: "rejected";
+        approved: false;
+        reason: string;
+        decidedBy?: string | undefined;
+        decidedAt?: string | undefined;
+    }, TContext>>;
+    static get<TOutcome, TContext = unknown>(runtime: TasksClientRuntime, id: string, outcomeSchema: TaskOutcomeSchema<TOutcome>): Promise<TaskHandle<TOutcome, TContext>>;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

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

package/dist/service.js

@@ -0,0 +1,521 @@
+import Ajv from "ajv";
+import { id as instantId } from "@instantdb/core";
+import { createHook } from "workflow";
+import { approvalOutcomeSchema } from "./approval.js";
+import { tasksDomain } from "./domain.js";
+import { assertStoredOutcomeSchemaMatches, createTaskHandle, storedOutcomeSchemasEqual, taskOutcomeToken, toStoredOutcomeSchema, } from "./task.js";
+async function runTaskDomainAction(runtime, action, input) {
+    const tasks = await tasksDomain(runtime);
+    const actions = tasks.actions;
+    return await actions[action](input);
+}
+function unwrapTaskResult(result) {
+    if (!result.ok)
+        throw new Error(result.error);
+    return result.data;
+}
+async function getTaskRecordThroughDomain(runtime, id) {
+    return unwrapTaskResult(await runTaskDomainAction(runtime, "getTask", { id }));
+}
+function unwrapOutcomeResult(result) {
+    if (!result.ok)
+        throw new Error(result.error);
+    return result.data;
+}
+function errorText(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
+function createDomainTaskHandle(runtime, record, outcomeSchema) {
+    assertStoredOutcomeSchemaMatches(outcomeSchema, record.outcomeSchema);
+    return createTaskHandle(record, outcomeSchema, {
+        async awaitOutcome() {
+            return unwrapOutcomeResult(await runTaskDomainAction(runtime, "awaitOutcome", { id: record.id }));
+        },
+        async start(data, work) {
+            const runId = newEntityId();
+            let terminal = false;
+            let lastRecord = null;
+            const completeWith = async (outcome) => {
+                lastRecord = unwrapTaskResult(await runTaskDomainAction(runtime, "completeTask", {
+                    id: data.id,
+                    runId,
+                    outcome,
+                }));
+                terminal = true;
+                return lastRecord;
+            };
+            const releaseWith = async (input) => {
+                lastRecord = unwrapTaskResult(await runTaskDomainAction(runtime, "releaseTask", {
+                    id: data.id,
+                    runId,
+                    actor: input?.actor,
+                    comment: input?.comment,
+                }));
+                terminal = true;
+                return lastRecord;
+            };
+            await runTaskDomainAction(runtime, "startTask", {
+                id: data.id,
+                runId,
+            });
+            const run = {
+                id: runId,
+                taskId: data.id,
+                completed: completeWith,
+                release: releaseWith,
+            };
+            try {
+                const returned = await work(run);
+                if (returned) {
+                    if (returned.state === "in_progress") {
+                        throw new Error("Task.start callback returned an in_progress task. A started task must finish with completed outcome or release.");
+                    }
+                    return returned;
+                }
+                if (!terminal) {
+                    throw new Error("Task.start callback finished without completing or releasing the task.");
+                }
+                if (!lastRecord) {
+                    throw new Error("Task.start callback did not return a task record.");
+                }
+                return lastRecord;
+            }
+            catch (error) {
+                if (!terminal) {
+                    try {
+                        await runTaskDomainAction(runtime, "failTask", {
+                            id: data.id,
+                            runId,
+                            errorText: errorText(error),
+                        });
+                    }
+                    catch {
+                        // Preserve the original runner failure.
+                    }
+                }
+                throw error;
+            }
+        },
+    });
+}
+let ajvInstance = null;
+function getAjv() {
+    if (!ajvInstance) {
+        ajvInstance = new Ajv({ allErrors: true, strict: false });
+    }
+    return ajvInstance;
+}
+function newEntityId() {
+    return instantId();
+}
+function normalizeTaskState(state) {
+    if (state === "open" ||
+        state === "completed" ||
+        state === "in_progress" ||
+        state === "cancelled" ||
+        state === "failed") {
+        return state;
+    }
+    return "open";
+}
+function rowToTaskRecord(row) {
+    return {
+        id: String(row.id),
+        kind: String(row.kind),
+        key: String(row.key),
+        state: normalizeTaskState(row.state),
+        instructions: String(row.instructions ?? ""),
+        context: row.context,
+        outcomeKind: typeof row.outcomeKind === "string" ? row.outcomeKind : undefined,
+        outcomeSchema: row.outcomeSchema,
+        resolvedOutcome: row.outcome,
+        activeRunId: typeof row.activeRunId === "string" ? row.activeRunId : undefined,
+        lastProgress: row.lastProgress,
+        errorText: typeof row.errorText === "string" ? row.errorText : undefined,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+        resolvedAt: row.resolvedAt,
+    };
+}
+function validateStoredOutcome(storedSchema, outcome) {
+    if (!storedSchema || storedSchema.type !== "json-schema") {
+        return { ok: false, error: "task_outcome_schema_missing" };
+    }
+    try {
+        const validate = getAjv().compile(storedSchema.schema);
+        if (!validate(outcome)) {
+            return {
+                ok: false,
+                error: "task_outcome_invalid",
+                issues: validate.errors ?? [],
+            };
+        }
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: "task_outcome_schema_invalid",
+            issues: error instanceof Error ? error.message : String(error),
+        };
+    }
+    return { ok: true, data: outcome };
+}
+async function resumeTaskOutcome(id, outcome) {
+    const { resumeHook } = await import("workflow/api");
+    try {
+        await resumeHook(taskOutcomeToken(id), outcome);
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "HookNotFoundError") {
+            return;
+        }
+        throw error;
+    }
+}
+async function resumeTaskFailure(id, error) {
+    const { resumeHook } = await import("workflow/api");
+    try {
+        await resumeHook(taskOutcomeToken(id), {
+            __ekairosTaskFailure: true,
+            error,
+        });
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "HookNotFoundError") {
+            return;
+        }
+        throw error;
+    }
+}
+function failureOutcomeError(task) {
+    if (task.state === "failed") {
+        return task.errorText || "task_failed";
+    }
+    if (task.state === "cancelled") {
+        return task.errorText || "task_cancelled";
+    }
+    return `task_not_open:${task.state}`;
+}
+function isFailureHookPayload(value) {
+    return !!value &&
+        typeof value === "object" &&
+        value.__ekairosTaskFailure === true;
+}
+function createTaskOutcomeHook(id) {
+    return createHook({
+        token: taskOutcomeToken(id),
+    });
+}
+export class TaskService {
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    db() {
+        return this.runtime.db;
+    }
+    async getTaskRecord(id) {
+        const db = this.db();
+        const result = await db.query({
+            task_tasks: {
+                $: { where: { id }, limit: 1 },
+            },
+        });
+        const row = result?.task_tasks?.[0];
+        return row?.id ? rowToTaskRecord(row) : null;
+    }
+    async openRaw(input) {
+        if (!input.kind.trim())
+            return { ok: false, error: "task_kind_required" };
+        if (!input.key.trim())
+            return { ok: false, error: "task_key_required" };
+        if (!input.outcomeSchema)
+            return { ok: false, error: "task_outcome_schema_required" };
+        const db = this.db();
+        const existing = await db.query({
+            task_tasks: {
+                $: { where: { key: input.key }, limit: 1 },
+            },
+        });
+        const existingTask = existing?.task_tasks?.[0];
+        if (existingTask?.id) {
+            const existingSchema = existingTask.outcomeSchema;
+            if (!storedOutcomeSchemasEqual(existingSchema, input.outcomeSchema)) {
+                return { ok: false, error: "task_outcome_schema_mismatch" };
+            }
+            return { ok: true, data: rowToTaskRecord(existingTask) };
+        }
+        const now = new Date();
+        const id = input.id ?? newEntityId();
+        await db.transact([
+            db.tx.task_tasks[id].update({
+                kind: input.kind,
+                key: input.key,
+                state: "open",
+                instructions: input.instructions,
+                context: input.context,
+                outcomeKind: input.outcomeKind,
+                outcomeSchema: input.outcomeSchema,
+                createdAt: now,
+                updatedAt: now,
+            }),
+        ]);
+        const created = await this.getTaskRecord(id);
+        if (!created)
+            return { ok: false, error: "task_open_failed" };
+        return { ok: true, data: created };
+    }
+    async decide(input) {
+        if (!input.id.trim())
+            return { ok: false, error: "task_id_required" };
+        const task = await this.getTaskRecord(input.id);
+        if (!task)
+            return { ok: false, error: "task_not_found" };
+        if (task.state !== "open" && task.state !== "in_progress") {
+            return { ok: false, error: `task_not_decidable:${task.state}` };
+        }
+        if (task.state === "in_progress" && !input.runId?.trim()) {
+            return { ok: false, error: "task_run_id_required" };
+        }
+        if (task.state === "in_progress" && task.activeRunId !== input.runId) {
+            return { ok: false, error: "task_run_mismatch" };
+        }
+        const validation = validateStoredOutcome(task.outcomeSchema, input.outcome);
+        if (!validation.ok)
+            return validation;
+        const db = this.db();
+        const now = new Date();
+        await db.transact([
+            db.tx.task_tasks[input.id].update({
+                state: "completed",
+                activeRunId: "",
+                outcome: validation.data,
+                lastProgress: {
+                    type: "completed",
+                    runId: input.runId,
+                    createdAt: now.toISOString(),
+                },
+                resolvedAt: now,
+                updatedAt: now,
+            }),
+        ]);
+        if (input.resumeWorkflow !== false) {
+            await resumeTaskOutcome(input.id, validation.data);
+        }
+        const completed = await this.getTaskRecord(input.id);
+        if (!completed)
+            return { ok: false, error: "task_not_found_after_decide" };
+        return { ok: true, data: completed };
+    }
+    async cancel(input) {
+        if (!input.id.trim())
+            return { ok: false, error: "task_id_required" };
+        const task = await this.getTaskRecord(input.id);
+        if (!task)
+            return { ok: false, error: "task_not_found" };
+        if (task.state !== "open" && task.state !== "in_progress") {
+            return { ok: false, error: `task_not_cancellable:${task.state}` };
+        }
+        if (task.state === "in_progress" && !input.runId?.trim()) {
+            return { ok: false, error: "task_run_id_required" };
+        }
+        if (task.state === "in_progress" && task.activeRunId !== input.runId) {
+            return { ok: false, error: "task_run_mismatch" };
+        }
+        const db = this.db();
+        const now = new Date();
+        await db.transact([
+            db.tx.task_tasks[input.id].update({
+                state: "cancelled",
+                activeRunId: "",
+                errorText: input.reason,
+                lastProgress: {
+                    type: "cancelled",
+                    runId: input.runId,
+                    comment: input.reason,
+                    createdAt: now.toISOString(),
+                },
+                resolvedAt: now,
+                updatedAt: now,
+            }),
+        ]);
+        const cancelled = await this.getTaskRecord(input.id);
+        if (!cancelled)
+            return { ok: false, error: "task_not_found_after_cancel" };
+        return { ok: true, data: cancelled };
+    }
+    async fail(input) {
+        if (!input.id.trim())
+            return { ok: false, error: "task_id_required" };
+        if (!input.errorText.trim())
+            return { ok: false, error: "task_error_text_required" };
+        const task = await this.getTaskRecord(input.id);
+        if (!task)
+            return { ok: false, error: "task_not_found" };
+        if (task.state !== "open" && task.state !== "in_progress") {
+            return { ok: false, error: `task_not_failable:${task.state}` };
+        }
+        if (task.state === "in_progress" && !input.runId?.trim()) {
+            return { ok: false, error: "task_run_id_required" };
+        }
+        if (task.state === "in_progress" && task.activeRunId !== input.runId) {
+            return { ok: false, error: "task_run_mismatch" };
+        }
+        const db = this.db();
+        const now = new Date();
+        await db.transact([
+            db.tx.task_tasks[input.id].update({
+                state: "failed",
+                activeRunId: "",
+                errorText: input.errorText,
+                lastProgress: {
+                    type: "failed",
+                    runId: input.runId,
+                    comment: input.errorText,
+                    createdAt: now.toISOString(),
+                },
+                resolvedAt: now,
+                updatedAt: now,
+            }),
+        ]);
+        await resumeTaskFailure(input.id, input.errorText);
+        const failed = await this.getTaskRecord(input.id);
+        if (!failed)
+            return { ok: false, error: "task_not_found_after_fail" };
+        return { ok: true, data: failed };
+    }
+    async getRaw(input) {
+        if (!input.id.trim())
+            return { ok: false, error: "task_id_required" };
+        const task = await this.getTaskRecord(input.id);
+        if (!task)
+            return { ok: false, error: "task_not_found" };
+        return { ok: true, data: task };
+    }
+    async awaitOutcome(input) {
+        if (!input.id.trim())
+            return { ok: false, error: "task_id_required" };
+        const task = await this.getTaskRecord(input.id);
+        if (!task)
+            return { ok: false, error: "task_not_found" };
+        if (task.state === "completed") {
+            return validateStoredOutcome(task.outcomeSchema, task.resolvedOutcome);
+        }
+        if (task.state === "failed" || task.state === "cancelled") {
+            return { ok: false, error: failureOutcomeError(task) };
+        }
+        if (task.state !== "open" && task.state !== "in_progress") {
+            return { ok: false, error: `task_not_open:${task.state}` };
+        }
+        const hook = createTaskOutcomeHook(input.id);
+        try {
+            const outcome = await hook;
+            if (isFailureHookPayload(outcome)) {
+                return { ok: false, error: String(outcome.error || "task_failed") };
+            }
+            return validateStoredOutcome(task.outcomeSchema, outcome);
+        }
+        finally {
+            hook.dispose();
+        }
+    }
+    async start(input) {
+        if (!input.id.trim())
+            return { ok: false, error: "task_id_required" };
+        if (!input.runId.trim())
+            return { ok: false, error: "task_run_id_required" };
+        const task = await this.getTaskRecord(input.id);
+        if (!task)
+            return { ok: false, error: "task_not_found" };
+        if (task.state !== "open") {
+            return { ok: false, error: `task_not_open:${task.state}` };
+        }
+        const db = this.db();
+        const now = new Date();
+        await db.transact([
+            db.tx.task_tasks[input.id].update({
+                state: "in_progress",
+                activeRunId: input.runId,
+                lastProgress: {
+                    type: "started",
+                    runId: input.runId,
+                    createdAt: now.toISOString(),
+                },
+                updatedAt: now,
+            }),
+        ]);
+        const started = await this.getTaskRecord(input.id);
+        if (!started)
+            return { ok: false, error: "task_not_found_after_start" };
+        return { ok: true, data: started };
+    }
+    async release(input) {
+        if (!input.id.trim())
+            return { ok: false, error: "task_id_required" };
+        if (!input.runId.trim())
+            return { ok: false, error: "task_run_id_required" };
+        const task = await this.getTaskRecord(input.id);
+        if (!task)
+            return { ok: false, error: "task_not_found" };
+        if (task.state !== "in_progress") {
+            return { ok: false, error: `task_not_in_progress:${task.state}` };
+        }
+        if (task.activeRunId !== input.runId) {
+            return { ok: false, error: "task_run_mismatch" };
+        }
+        const db = this.db();
+        const now = new Date();
+        await db.transact([
+            db.tx.task_tasks[input.id].update({
+                state: "open",
+                activeRunId: "",
+                lastProgress: {
+                    type: "released",
+                    runId: input.runId,
+                    actor: input.actor,
+                    comment: input.comment?.trim() || undefined,
+                    createdAt: now.toISOString(),
+                },
+                updatedAt: now,
+            }),
+        ]);
+        const released = await this.getTaskRecord(input.id);
+        if (!released)
+            return { ok: false, error: "task_not_found_after_release" };
+        return { ok: true, data: released };
+    }
+}
+export class Task {
+    static async create(runtime, input) {
+        return await Task.open(runtime, input);
+    }
+    static async open(runtime, input) {
+        const opened = unwrapTaskResult(await runTaskDomainAction(runtime, "createTask", {
+            id: input.id,
+            kind: input.kind,
+            key: input.key,
+            instructions: input.instructions,
+            context: input.context,
+            outcomeKind: input.outcomeKind,
+            outcomeSchema: toStoredOutcomeSchema(input.outcome),
+        }));
+        return createDomainTaskHandle(runtime, opened, input.outcome);
+    }
+    static async approval(runtime, input) {
+        return await Task.open(runtime, {
+            id: input.id,
+            kind: "approval",
+            key: input.key,
+            outcome: approvalOutcomeSchema,
+            instructions: input.instructions,
+            context: input.context,
+            outcomeKind: "approval",
+        });
+    }
+    static async get(runtime, id, outcomeSchema) {
+        const task = await getTaskRecordThroughDomain(runtime, id);
+        return createDomainTaskHandle(runtime, task, outcomeSchema);
+    }
+}
+//# sourceMappingURL=service.js.map