@corbits/mcp 0.3.1 → 0.4.1

package/dist/extensions/skills/index.js

@@ -0,0 +1,402 @@
+import { parseDocument, visit, isAlias } from "yaml";
+import { type } from "arktype";
+import { validateSkill } from "../../protocol/index.js";
+export const SKILL_LIMITS = Object.freeze({
+    resources: 512,
+    bytes: 16_777_216,
+});
+const frontmatterShape = type({ name: "string", description: "string" });
+const fail = (message) => {
+    throw Object.assign(new Error(message), { code: -32602 });
+};
+const encoder = new TextEncoder();
+const canonical = (value) => {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(",")}]`;
+    if (value !== null && typeof value === "object")
+        return `{${Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([k, v]) => `${JSON.stringify(k)}:${canonical(v)}`)
+            .join(",")}}`;
+    return JSON.stringify(value) ?? fail("Non-JSON frontmatter");
+};
+function skillBody(entry) {
+    const resources = entry.resources;
+    if (resources === "dynamic")
+        return fail("Dynamic skills unsupported");
+    return canonical({
+        frontmatter: entry.frontmatter,
+        resources: [...resources].sort((a, b) => a.uri.localeCompare(b.uri)),
+    });
+}
+async function digest(bytes) {
+    const hash = await crypto.subtle.digest("SHA-256", new Uint8Array(bytes));
+    return `sha256:${Array.from(new Uint8Array(hash), (b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+function safeUri(uri) {
+    const parsed = new URL(uri);
+    if (parsed.search ||
+        parsed.hash ||
+        parsed.username ||
+        parsed.password ||
+        /[\\\s]/u.test(uri))
+        fail("Unsafe skill URI");
+    const segments = uri.slice(uri.indexOf(":") + 1).split("/");
+    for (const segment of segments) {
+        const decoded = decodeURIComponent(segment);
+        if (decoded === "." ||
+            decoded === ".." ||
+            /[/\\]/u.test(decoded) ||
+            decoded.includes(String.fromCharCode(0)))
+            fail("Unsafe skill path");
+    }
+}
+function checkFrontmatter(value, uri) {
+    const parsed = frontmatterShape(value);
+    if (parsed instanceof type.errors)
+        return fail("Invalid skill frontmatter");
+    const { name, description } = parsed;
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(name) ||
+        name.length > 64 ||
+        !description.trim() ||
+        description.length > 1024)
+        fail("Invalid skill name or description");
+    if (!uri.endsWith(`/${name}/SKILL.md`))
+        fail("Skill name does not match directory");
+    const fm = value;
+    if (fm.compatibility !== undefined &&
+        (typeof fm.compatibility !== "string" ||
+            !fm.compatibility.length ||
+            fm.compatibility.length > 500))
+        fail("Invalid compatibility");
+    for (const key of ["license", "allowed-tools"])
+        if (fm[key] !== undefined && typeof fm[key] !== "string")
+            fail(`Invalid ${key}`);
+    if (fm.metadata !== undefined &&
+        (fm.metadata === null ||
+            typeof fm.metadata !== "object" ||
+            Array.isArray(fm.metadata) ||
+            Object.values(fm.metadata).some((v) => typeof v !== "string")))
+        fail("Invalid metadata");
+    return fm;
+}
+export function parseSkillFrontmatter(bytes, uri) {
+    if (bytes.byteLength > SKILL_LIMITS.bytes)
+        fail("Skill exceeds 16 MiB");
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/u.exec(text);
+    if (!match)
+        return fail("Missing YAML frontmatter");
+    // Bound parser nesting before conversion, and prohibit aliases entirely.
+    const doc = parseDocument(match[1], { schema: "core", uniqueKeys: true });
+    if (doc.errors.length)
+        fail("Invalid YAML frontmatter");
+    let nodes = 0;
+    visit(doc, (_key, node, path) => {
+        if (isAlias(node) || path.length > 32 || ++nodes > 100_000)
+            fail("Frontmatter structure limit or alias");
+    });
+    const value = doc.toJS({ maxAliasCount: 0 });
+    const inspect = (v, depth) => {
+        if (depth > 32)
+            fail("Frontmatter nesting limit");
+        if (v !== null && typeof v === "object")
+            for (const child of Object.values(v))
+                inspect(child, depth + 1);
+        else if (!["string", "number", "boolean"].includes(typeof v) && v !== null)
+            fail("Non-JSON frontmatter");
+        if (typeof v === "number" && !Number.isFinite(v))
+            fail("Non-JSON number");
+    };
+    inspect(value, 0);
+    return checkFrontmatter(value, uri);
+}
+function checkEntry(entry) {
+    validateSkill(entry);
+    safeUri(entry.uri);
+    checkFrontmatter(entry.frontmatter, entry.uri);
+    if (entry.resources === "dynamic")
+        return fail("Dynamic skills cannot be content-bound and are not supported");
+    if (!Array.isArray(entry.resources) ||
+        entry.resources.length > SKILL_LIMITS.resources)
+        fail("Skill exceeds 512 resources or lacks manifest");
+    const root = entry.uri.slice(0, -"SKILL.md".length);
+    let total = 0;
+    for (const file of entry.resources) {
+        safeUri(file.uri);
+        if (!file.uri.startsWith(root) || file.uri.endsWith("/"))
+            fail("Manifest has duplicate or out-of-directory file");
+        total += file.size;
+    }
+    if (total > SKILL_LIMITS.bytes)
+        fail("Skill exceeds 16 MiB");
+}
+function freeze(value) {
+    if (value !== null && typeof value === "object") {
+        for (const child of Object.values(value))
+            freeze(child);
+        Object.freeze(value);
+    }
+    return value;
+}
+export function createSkillLoader(source, host) {
+    const heldEntries = new WeakMap();
+    const current = new Map();
+    const approvals = new Map();
+    const cache = new Map();
+    let cacheBytes = 0;
+    async function hold(origin, entry) {
+        if (Object.values(origin).some((v) => !v))
+            fail("Host origin identity required");
+        const snapshot = structuredClone(entry);
+        const originSnapshot = structuredClone(origin);
+        checkEntry(snapshot);
+        const identity = canonical([
+            originSnapshot.serverId,
+            originSnapshot.tenantId,
+            originSnapshot.principalId,
+            originSnapshot.authorizationContextId,
+            snapshot.uri,
+        ]);
+        const canonicalBody = skillBody(snapshot);
+        const fingerprint = await digest(encoder.encode(canonicalBody));
+        let diverged = true;
+        try {
+            diverged = skillBody(entry) !== canonicalBody;
+        }
+        catch {
+            diverged = true;
+        }
+        if (diverged || current.get(identity)?.fingerprint !== fingerprint) {
+            approvals.delete(identity);
+            current.set(identity, { fingerprint, generation: {} });
+        }
+        const generation = current.get(identity).generation;
+        const held = freeze({
+            origin: originSnapshot,
+            entry: snapshot,
+            identity,
+            fingerprint,
+        });
+        heldEntries.set(held, generation);
+        return held;
+    }
+    function assertCurrent(held) {
+        if (!heldEntries.has(held) ||
+            current.get(held.identity)?.generation !== heldEntries.get(held))
+            fail("Skill entry revoked; refresh and reapprove");
+    }
+    async function verify(held, uri = held.entry.uri) {
+        assertCurrent(held);
+        try {
+            const files = held.entry.resources;
+            if (files === "dynamic")
+                return fail("Dynamic skills unsupported");
+            const file = files.find((f) => f.uri === uri);
+            if (!file)
+                return fail("Unlisted skill file");
+            const key = canonical([held.identity, uri, file.digest]);
+            const bytes = new Uint8Array(cache.get(key) ?? (await source.read(held.origin, uri, file.size)));
+            assertCurrent(held);
+            if (bytes.byteLength !== file.size)
+                return fail("Skill integrity mismatch");
+            const actualDigest = await digest(bytes);
+            // A source read or digest can finish after refresh/clear. Reject stale
+            // work before parsing frontmatter, changing the cache, or exposing bytes.
+            assertCurrent(held);
+            if (actualDigest !== file.digest) {
+                cache.delete(key);
+                return fail("Skill integrity mismatch");
+            }
+            if (uri === held.entry.uri &&
+                canonical(parseSkillFrontmatter(bytes, uri)) !==
+                    canonical(held.entry.frontmatter))
+                return fail("Skill frontmatter mismatch");
+            if (!cache.has(key)) {
+                if (cacheBytes + bytes.length > SKILL_LIMITS.bytes) {
+                    cache.clear();
+                    cacheBytes = 0;
+                }
+                cache.set(key, bytes.slice());
+                cacheBytes += bytes.length;
+            }
+            return { held, uri, bytes, trust: "untrusted-mcp" };
+        }
+        catch (error) {
+            // Every verification failure, including source, digest and YAML errors,
+            // may invalidate only the generation that initiated this verification.
+            if (current.get(held.identity)?.generation === heldEntries.get(held)) {
+                approvals.delete(held.identity);
+                current.delete(held.identity);
+            }
+            throw error;
+        }
+    }
+    async function activate(held) {
+        assertCurrent(held);
+        if (!host)
+            return fail("Skill host policy unavailable; verified bytes are not activation");
+        let approval = approvals.get(held.identity);
+        if (!approval) {
+            approval = await host.approve(held);
+            if (approval.approved !== true ||
+                approval.identity !== held.identity ||
+                approval.fingerprint !== held.fingerprint)
+                return fail("Skill approval denied or mismatched");
+            approval = freeze(structuredClone(approval));
+            assertCurrent(held);
+            approvals.set(held.identity, approval);
+        }
+        const content = await verify(held);
+        let active = true;
+        const assertExecutionApproved = () => {
+            assertCurrent(held);
+            if (!active || !approvals.get(held.identity)?.execution)
+                fail("Explicit per-skill execution approval required");
+        };
+        const window = await host.openActingWindow(held, approval, {
+            assertExecutionApproved,
+        });
+        try {
+            assertCurrent(held);
+            await window.admit(content);
+        }
+        catch (error) {
+            await window.removeContext();
+            await window.close();
+            throw error;
+        }
+        return {
+            held,
+            read: (uri) => {
+                if (!active)
+                    return Promise.reject(new Error("Skill lease closed"));
+                return verify(held, uri);
+            },
+            assertExecutionApproved,
+            async release() {
+                if (active) {
+                    await window.removeContext();
+                    await window.close();
+                    active = false;
+                }
+            },
+        };
+    }
+    return {
+        hold,
+        verify,
+        activate,
+        async get(origin, uri) {
+            const entry = await source.get(origin, uri);
+            if (entry.uri !== uri)
+                return fail("Skill URI mismatch");
+            return hold(origin, entry);
+        },
+        clear() {
+            cache.clear();
+            cacheBytes = 0;
+            approvals.clear();
+            current.clear();
+        },
+    };
+}
+/** In-memory immutable snapshot publisher. Host must authorize all methods using the same identity. */
+export async function createSkillPublisher(publications) {
+    const skills = new Map();
+    const files = new Map();
+    for (const original of publications) {
+        const publication = {
+            uri: original.uri,
+            files: new Map([...original.files].map(([uri, bytes]) => [uri, bytes.slice()])),
+        };
+        if (skills.has(publication.uri))
+            fail("Duplicate skill publication");
+        const main = publication.files.get(publication.uri);
+        if (!main)
+            return fail("Publication omits SKILL.md");
+        const resources = await Promise.all([...publication.files].map(async ([uri, bytes]) => ({
+            uri,
+            digest: await digest(bytes),
+            size: bytes.length,
+        })));
+        const entry = {
+            uri: publication.uri,
+            frontmatter: parseSkillFrontmatter(main, publication.uri),
+            resources,
+        };
+        checkEntry(entry);
+        skills.set(entry.uri, entry);
+        for (const [uri, bytes] of publication.files) {
+            const previous = files.get(uri);
+            if (previous && (await digest(previous)) !== (await digest(bytes)))
+                fail("Conflicting nested publication");
+            files.set(uri, bytes.slice());
+        }
+    }
+    for (const skill of skills.values()) {
+        const root = skill.uri.slice(0, -"SKILL.md".length);
+        if (skill.resources !== "dynamic")
+            for (const uri of files.keys())
+                if (uri.startsWith(root) &&
+                    !skill.resources.some((file) => file.uri === uri))
+                    fail("Incomplete enclosing skill manifest");
+    }
+    return {
+        list() {
+            return {
+                resultType: "complete",
+                ttlMs: 0,
+                cacheScope: "private",
+                skills: structuredClone([...skills.values()]),
+            };
+        },
+        get(uri) {
+            const skill = skills.get(uri);
+            if (!skill)
+                return fail("Unknown skill");
+            return {
+                resultType: "complete",
+                ttlMs: 0,
+                cacheScope: "private",
+                skill: structuredClone(skill),
+            };
+        },
+        read(uri) {
+            const bytes = files.get(uri);
+            if (!bytes)
+                return fail("Unknown resource");
+            return {
+                resultType: "complete",
+                ttlMs: 0,
+                cacheScope: "private",
+                contents: [{ uri, blob: Buffer.from(bytes).toString("base64") }],
+            };
+        },
+        directoryRead(uri) {
+            safeUri(uri);
+            if (uri.endsWith("/"))
+                fail("Directory URI must not end in slash");
+            const children = new Map();
+            for (const file of files.keys())
+                if (file.startsWith(`${uri}/`)) {
+                    const relative = file.slice(uri.length + 1);
+                    const name = relative.split("/")[0];
+                    const directory = relative.includes("/");
+                    children.set(`${directory ? "d" : "f"}:${name}`, {
+                        uri: `${uri}/${name}`,
+                        name,
+                        ...(directory ? { mimeType: "inode/directory" } : {}),
+                    });
+                }
+            if (!children.size)
+                return fail("Unknown directory");
+            return {
+                resultType: "complete",
+                ttlMs: 0,
+                cacheScope: "private",
+                resources: [...children.values()],
+            };
+        },
+    };
+}

package/dist/extensions/tasks/contracts.d.ts

@@ -0,0 +1,39 @@
+import type { DetailedTask, InputRequests, InputResponses } from "../../protocol/index.js";
+export interface McpTaskIdentity {
+    tenantId: string;
+    principalId: string;
+    authorizationContextId: string;
+}
+export interface McpTaskRecord {
+    identity: McpTaskIdentity;
+    task: DetailedTask;
+    revision: number;
+    original: {
+        method: "tools/call";
+        params: Record<string, unknown>;
+    };
+    backend: Record<string, string>;
+    /** Immutable history prevents key reuse even after requests are answered. */
+    issued: InputRequests;
+    answered: InputResponses;
+    cancelRequested: boolean;
+    dispatch: "pending" | "started";
+}
+/** All operations are atomic, linearizable and durable before resolving. */
+export interface McpTaskStore {
+    readonly durable: true;
+    create(record: McpTaskRecord): Promise<void>;
+    get(taskId: string): Promise<McpTaskRecord | undefined>;
+    compareAndSwap(taskId: string, revision: number, next: McpTaskRecord): Promise<boolean>;
+    list(): Promise<McpTaskRecord[]>;
+    expire(now: number): Promise<void>;
+}
+export interface McpTaskExecutor {
+    /** Start uses taskId as idempotency/correlation key; never hide ambiguous dispatch. */
+    start(record: McpTaskRecord): Promise<void>;
+    /** Reconcile backend state, including pending dispatch/input/cancel; do not blindly replay. */
+    recover(record: McpTaskRecord): Promise<DetailedTask | undefined>;
+    /** Responses already persisted. Host must authorize each approval/input binding. */
+    submitInput(record: McpTaskRecord, responses: InputResponses): Promise<void>;
+    requestCancel(record: McpTaskRecord): Promise<void>;
+}

package/dist/extensions/tasks/contracts.js

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

package/dist/extensions/tasks/file-store.d.ts

@@ -0,0 +1,12 @@
+import type { McpTaskRecord, McpTaskStore } from "./contracts.js";
+/** Single writer on a local filesystem only. A crash leaves the lock: host must
+ * prove the previous writer dead before removing it. Never auto-steal a lock.
+ * Directory must be host-owned, not writable by models/tools/other users.
+ */
+export declare function createFileTaskStore(options: {
+    directory: string;
+    /** Shared boundary validation plus host record invariants on restart. */
+    validateRecord(value: unknown): McpTaskRecord;
+}): Promise<McpTaskStore & {
+    close(): Promise<void>;
+}>;

package/dist/extensions/tasks/file-store.js

@@ -0,0 +1,152 @@
+/** Explicit server-only import. Not re-exported by the neutral extensions entry. */
+import { open, mkdir, rename, unlink, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { type } from "arktype";
+const envelope = type({ version: "1", records: "unknown[]" });
+const MAX_STORE_BYTES = 16_777_216;
+/** Single writer on a local filesystem only. A crash leaves the lock: host must
+ * prove the previous writer dead before removing it. Never auto-steal a lock.
+ * Directory must be host-owned, not writable by models/tools/other users.
+ */
+export async function createFileTaskStore(options) {
+    await mkdir(options.directory, { recursive: true, mode: 0o700 });
+    const directoryStat = await stat(options.directory);
+    if ((directoryStat.mode & 0o077) !== 0)
+        throw new Error("Task directory must be private (0700)");
+    const lockPath = join(options.directory, "writer.lock");
+    const lock = await open(lockPath, "wx", 0o600);
+    const dataPath = join(options.directory, "tasks.json");
+    let records = new Map();
+    let closed = false;
+    let closing;
+    let queue = Promise.resolve();
+    const serialized = (run) => {
+        if (closing)
+            return Promise.reject(new Error("Task store closed"));
+        const result = queue.then(() => {
+            if (closed)
+                throw new Error("Task store closed");
+            return run();
+        });
+        queue = result.catch(() => { });
+        return result;
+    };
+    try {
+        await lock.writeFile(JSON.stringify({ pid: process.pid }));
+        await lock.sync();
+        let file;
+        try {
+            file = await open(dataPath, "r");
+        }
+        catch (error) {
+            if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+                throw error;
+        }
+        if (file)
+            try {
+                if ((await file.stat()).size > MAX_STORE_BYTES)
+                    throw new Error("Task store exceeds 16 MiB");
+                const parsed = envelope(JSON.parse(await file.readFile("utf8")));
+                if (parsed instanceof type.errors)
+                    throw new Error("Invalid task store envelope");
+                for (const value of parsed.records) {
+                    const record = options.validateRecord(value);
+                    if (records.has(record.task.taskId))
+                        throw new Error("Duplicate persisted task");
+                    records.set(record.task.taskId, structuredClone(record));
+                }
+            }
+            finally {
+                await file.close();
+            }
+    }
+    catch (error) {
+        await lock.close();
+        await unlink(lockPath);
+        throw error;
+    }
+    async function persist(next) {
+        const bytes = JSON.stringify({ version: 1, records: [...next.values()] });
+        if (Buffer.byteLength(bytes) > MAX_STORE_BYTES)
+            throw new Error("Task store exceeds 16 MiB");
+        const tempPath = join(options.directory, `tasks-${crypto.randomUUID()}.tmp`);
+        const temp = await open(tempPath, "wx", 0o600);
+        try {
+            await temp.writeFile(bytes);
+            await temp.sync();
+        }
+        finally {
+            await temp.close();
+        }
+        try {
+            await rename(tempPath, dataPath);
+            const directory = await open(options.directory, "r");
+            try {
+                await directory.sync();
+            }
+            finally {
+                await directory.close();
+            }
+            records = next;
+        }
+        catch (error) {
+            // An ambiguous durability failure poisons this writer; restart reconciles disk.
+            closed = true;
+            throw error;
+        }
+    }
+    return {
+        durable: true,
+        create(record) {
+            return serialized(async () => {
+                if (records.has(record.task.taskId) || record.revision !== 0)
+                    throw new Error("Task exists or invalid initial revision");
+                const checked = options.validateRecord(structuredClone(record));
+                const next = new Map(records);
+                next.set(record.task.taskId, checked);
+                await persist(next);
+            });
+        },
+        get(taskId) {
+            return serialized(async () => structuredClone(records.get(taskId)));
+        },
+        compareAndSwap(taskId, revision, record) {
+            return serialized(async () => {
+                const current = records.get(taskId);
+                if (!current || current.revision !== revision)
+                    return false;
+                if (record.task.taskId !== taskId ||
+                    record.revision !== revision + 1 ||
+                    JSON.stringify(record.identity) !== JSON.stringify(current.identity))
+                    throw new Error("Invalid task CAS identity/revision");
+                const checked = options.validateRecord(structuredClone(record));
+                const next = new Map(records);
+                next.set(taskId, checked);
+                await persist(next);
+                return true;
+            });
+        },
+        list() {
+            return serialized(async () => structuredClone([...records.values()]));
+        },
+        expire(now) {
+            return serialized(async () => {
+                const next = new Map([...records].filter(([, r]) => r.task.ttlMs === null ||
+                    Date.parse(r.task.createdAt) + r.task.ttlMs > now));
+                if (next.size !== records.size)
+                    await persist(next);
+            });
+        },
+        close() {
+            // Publish the close promise synchronously: reject new operations while
+            // draining accepted ones, and never unlink a successor's lock on retry.
+            closing ??= (async () => {
+                await queue;
+                closed = true;
+                await lock.close();
+                await unlink(lockPath);
+            })();
+            return closing;
+        },
+    };
+}

package/dist/extensions/tasks/index.d.ts

@@ -0,0 +1,82 @@
+import type { DetailedTask, InputRequests, InputResponses } from "../../protocol/index.js";
+import type { McpTaskExecutor, McpTaskIdentity, McpTaskRecord, McpTaskStore } from "./contracts.js";
+export type * from "./contracts.js";
+export declare function createTaskRuntime(options: {
+    store: McpTaskStore;
+    executor: McpTaskExecutor;
+    /** Shared protocol validator supplied by adapter, not a second wire validator. */
+    validateTask?(task: DetailedTask): void;
+    authorizeInput(identity: McpTaskIdentity, record: McpTaskRecord, responses: InputResponses): Promise<void>;
+    now?: () => number;
+}): {
+    create(identity: McpTaskIdentity, params: Record<string, unknown>, ttlMs?: number | null): Promise<{
+        taskId: string;
+        status: "cancelled" | "working";
+        createdAt: string;
+        lastUpdatedAt: string;
+        ttlMs: number | null;
+        pollIntervalMs?: number;
+        statusMessage?: string;
+        resultType: "task";
+    }>;
+    get(identity: McpTaskIdentity, taskId: string): Promise<{
+        resultType: "complete";
+        taskId: string;
+        status: "cancelled" | "working";
+        createdAt: string;
+        lastUpdatedAt: string;
+        ttlMs: number | null;
+        pollIntervalMs?: number;
+        statusMessage?: string;
+    } | {
+        resultType: "complete";
+        taskId: string;
+        status: "input_required";
+        createdAt: string;
+        lastUpdatedAt: string;
+        ttlMs: number | null;
+        pollIntervalMs?: number;
+        statusMessage?: string;
+        inputRequests: InputRequests;
+    } | {
+        resultType: "complete";
+        taskId: string;
+        status: "completed";
+        createdAt: string;
+        lastUpdatedAt: string;
+        ttlMs: number | null;
+        pollIntervalMs?: number;
+        statusMessage?: string;
+        result: Record<string, unknown>;
+    } | {
+        resultType: "complete";
+        taskId: string;
+        status: "failed";
+        createdAt: string;
+        lastUpdatedAt: string;
+        ttlMs: number | null;
+        pollIntervalMs?: number;
+        statusMessage?: string;
+        error: import("../../protocol/types.js").McpRpcError;
+    }>;
+    transition: (identity: McpTaskIdentity, taskId: string, task: DetailedTask, backend?: Record<string, string>) => Promise<McpTaskRecord>;
+    submitInput(identity: McpTaskIdentity, taskId: string, responses: InputResponses): Promise<{
+        resultType: "complete";
+    }>;
+    cancel(identity: McpTaskIdentity, taskId: string): Promise<{
+        resultType: "complete";
+    }>;
+    recover(): Promise<void>;
+};
+export declare function pollTask(options: {
+    taskId: string;
+    get(taskId: string): Promise<DetailedTask>;
+    update(taskId: string, responses: InputResponses): Promise<void>;
+    persist(taskId: string): Promise<void>;
+    input?(requests: InputRequests): Promise<InputResponses>;
+    observe?(task: DetailedTask): void;
+    signal?: AbortSignal;
+    maxPolls?: number;
+    sleep?: (milliseconds: number, signal?: AbortSignal) => Promise<void>;
+}): Promise<DetailedTask>;
+export { validateTaskRecord } from "./record.js";