@octonodes/sdk 0.2.13 → 0.2.26

package/dist/plugins/schema/ipc/envelope.d.ts

@@ -0,0 +1,923 @@
+import { z } from "zod";
+/**
+ * The IPC protocol version. Every envelope carries this in its `octonode`
+ * field so the wire format can evolve without ambiguity. Bump only on a
+ * breaking change to the envelope shape.
+ */
+export declare const PROTOCOL_VERSION: "1";
+/**
+ * A JSON Schema object, kept deliberately loose. It is the lowest common
+ * denominator every language can emit and validate against, which is what
+ * makes "a node in any language" tractable: contracts travel as plain JSON
+ * Schema, not as language-specific type objects.
+ */
+export declare const JsonSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type JsonSchema = Record<string, unknown>;
+/**
+ * Structured error codes a node (or the engine) can report. `retryable` on the
+ * error object — not the code alone — is what the DAG executor consults in
+ * later phases, but the code gives callers a stable taxonomy.
+ */
+export declare const ErrorCode: z.ZodEnum<["VALIDATION_ERROR", "RUNTIME_ERROR", "TIMEOUT", "NON_RETRYABLE"]>;
+export type ErrorCode = z.infer<typeof ErrorCode>;
+/**
+ * Per-invocation context handed to the node. In Phase 1/2 only `config`/`attempt`
+ * are meaningful; `runId`/`env`/`deadlineMs` are populated once the config and
+ * DAG layers land, but they are part of the contract from day one.
+ */
+export declare const InvocationContext: z.ZodObject<{
+    runId: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodString>;
+    config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    attempt: z.ZodDefault<z.ZodNumber>;
+    deadlineMs: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    config: Record<string, unknown>;
+    attempt: number;
+    runId?: string | undefined;
+    env?: string | undefined;
+    deadlineMs?: number | undefined;
+}, {
+    config?: Record<string, unknown> | undefined;
+    runId?: string | undefined;
+    env?: string | undefined;
+    attempt?: number | undefined;
+    deadlineMs?: number | undefined;
+}>;
+export type InvocationContext = z.infer<typeof InvocationContext>;
+/** Engine → node: a request to execute the node with the given inputs. */
+export declare const InvokeRequest: z.ZodObject<{
+    octonode: z.ZodLiteral<"1">;
+    type: z.ZodLiteral<"invoke">;
+    invocationId: z.ZodString;
+    /** Optional node id — useful once one process can host multiple nodes. */
+    node: z.ZodOptional<z.ZodString>;
+    inputs: z.ZodUnknown;
+    context: z.ZodDefault<z.ZodObject<{
+        runId: z.ZodOptional<z.ZodString>;
+        env: z.ZodOptional<z.ZodString>;
+        config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        attempt: z.ZodDefault<z.ZodNumber>;
+        deadlineMs: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        config: Record<string, unknown>;
+        attempt: number;
+        runId?: string | undefined;
+        env?: string | undefined;
+        deadlineMs?: number | undefined;
+    }, {
+        config?: Record<string, unknown> | undefined;
+        runId?: string | undefined;
+        env?: string | undefined;
+        attempt?: number | undefined;
+        deadlineMs?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "invoke";
+    octonode: "1";
+    invocationId: string;
+    context: {
+        config: Record<string, unknown>;
+        attempt: number;
+        runId?: string | undefined;
+        env?: string | undefined;
+        deadlineMs?: number | undefined;
+    };
+    node?: string | undefined;
+    inputs?: unknown;
+}, {
+    type: "invoke";
+    octonode: "1";
+    invocationId: string;
+    node?: string | undefined;
+    inputs?: unknown;
+    context?: {
+        config?: Record<string, unknown> | undefined;
+        runId?: string | undefined;
+        env?: string | undefined;
+        attempt?: number | undefined;
+        deadlineMs?: number | undefined;
+    } | undefined;
+}>;
+export type InvokeRequest = z.infer<typeof InvokeRequest>;
+/**
+ * Engine → node: a request for the node to self-report its manifest instead of
+ * executing. This is the universal discovery mechanism — every language that
+ * can answer `describe` can be scanned into `.octonode`, no AST tooling needed.
+ */
+export declare const DescribeRequest: z.ZodObject<{
+    octonode: z.ZodLiteral<"1">;
+    type: z.ZodLiteral<"describe">;
+    invocationId: z.ZodString;
+    node: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "describe";
+    octonode: "1";
+    invocationId: string;
+    node?: string | undefined;
+}, {
+    type: "describe";
+    octonode: "1";
+    invocationId: string;
+    node?: string | undefined;
+}>;
+export type DescribeRequest = z.infer<typeof DescribeRequest>;
+/** Any engine → node request. */
+export declare const RequestEnvelope: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    octonode: z.ZodLiteral<"1">;
+    type: z.ZodLiteral<"invoke">;
+    invocationId: z.ZodString;
+    /** Optional node id — useful once one process can host multiple nodes. */
+    node: z.ZodOptional<z.ZodString>;
+    inputs: z.ZodUnknown;
+    context: z.ZodDefault<z.ZodObject<{
+        runId: z.ZodOptional<z.ZodString>;
+        env: z.ZodOptional<z.ZodString>;
+        config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        attempt: z.ZodDefault<z.ZodNumber>;
+        deadlineMs: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        config: Record<string, unknown>;
+        attempt: number;
+        runId?: string | undefined;
+        env?: string | undefined;
+        deadlineMs?: number | undefined;
+    }, {
+        config?: Record<string, unknown> | undefined;
+        runId?: string | undefined;
+        env?: string | undefined;
+        attempt?: number | undefined;
+        deadlineMs?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "invoke";
+    octonode: "1";
+    invocationId: string;
+    context: {
+        config: Record<string, unknown>;
+        attempt: number;
+        runId?: string | undefined;
+        env?: string | undefined;
+        deadlineMs?: number | undefined;
+    };
+    node?: string | undefined;
+    inputs?: unknown;
+}, {
+    type: "invoke";
+    octonode: "1";
+    invocationId: string;
+    node?: string | undefined;
+    inputs?: unknown;
+    context?: {
+        config?: Record<string, unknown> | undefined;
+        runId?: string | undefined;
+        env?: string | undefined;
+        attempt?: number | undefined;
+        deadlineMs?: number | undefined;
+    } | undefined;
+}>, z.ZodObject<{
+    octonode: z.ZodLiteral<"1">;
+    type: z.ZodLiteral<"describe">;
+    invocationId: z.ZodString;
+    node: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "describe";
+    octonode: "1";
+    invocationId: string;
+    node?: string | undefined;
+}, {
+    type: "describe";
+    octonode: "1";
+    invocationId: string;
+    node?: string | undefined;
+}>]>;
+export type RequestEnvelope = z.infer<typeof RequestEnvelope>;
+/** Errors are data, not just exceptions — they cross the process boundary as JSON. */
+export declare const NodeError: z.ZodObject<{
+    code: z.ZodEnum<["VALIDATION_ERROR", "RUNTIME_ERROR", "TIMEOUT", "NON_RETRYABLE"]>;
+    message: z.ZodString;
+    retryable: z.ZodDefault<z.ZodBoolean>;
+    details: z.ZodOptional<z.ZodUnknown>;
+    stack: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    code: "VALIDATION_ERROR" | "RUNTIME_ERROR" | "TIMEOUT" | "NON_RETRYABLE";
+    message: string;
+    retryable: boolean;
+    details?: unknown;
+    stack?: string | undefined;
+}, {
+    code: "VALIDATION_ERROR" | "RUNTIME_ERROR" | "TIMEOUT" | "NON_RETRYABLE";
+    message: string;
+    retryable?: boolean | undefined;
+    details?: unknown;
+    stack?: string | undefined;
+}>;
+export type NodeError = z.infer<typeof NodeError>;
+declare const ResultOk: z.ZodObject<{
+    octonode: z.ZodLiteral<"1">;
+    type: z.ZodLiteral<"result">;
+    invocationId: z.ZodString;
+    status: z.ZodLiteral<"ok">;
+    outputs: z.ZodUnknown;
+}, "strip", z.ZodTypeAny, {
+    type: "result";
+    octonode: "1";
+    status: "ok";
+    invocationId: string;
+    outputs?: unknown;
+}, {
+    type: "result";
+    octonode: "1";
+    status: "ok";
+    invocationId: string;
+    outputs?: unknown;
+}>;
+declare const ResultErr: z.ZodObject<{
+    octonode: z.ZodLiteral<"1">;
+    type: z.ZodLiteral<"result">;
+    invocationId: z.ZodString;
+    status: z.ZodLiteral<"error">;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["VALIDATION_ERROR", "RUNTIME_ERROR", "TIMEOUT", "NON_RETRYABLE"]>;
+        message: z.ZodString;
+        retryable: z.ZodDefault<z.ZodBoolean>;
+        details: z.ZodOptional<z.ZodUnknown>;
+        stack: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        code: "VALIDATION_ERROR" | "RUNTIME_ERROR" | "TIMEOUT" | "NON_RETRYABLE";
+        message: string;
+        retryable: boolean;
+        details?: unknown;
+        stack?: string | undefined;
+    }, {
+        code: "VALIDATION_ERROR" | "RUNTIME_ERROR" | "TIMEOUT" | "NON_RETRYABLE";
+        message: string;
+        retryable?: boolean | undefined;
+        details?: unknown;
+        stack?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    error: {
+        code: "VALIDATION_ERROR" | "RUNTIME_ERROR" | "TIMEOUT" | "NON_RETRYABLE";
+        message: string;
+        retryable: boolean;
+        details?: unknown;
+        stack?: string | undefined;
+    };
+    type: "result";
+    octonode: "1";
+    status: "error";
+    invocationId: string;
+}, {
+    error: {
+        code: "VALIDATION_ERROR" | "RUNTIME_ERROR" | "TIMEOUT" | "NON_RETRYABLE";
+        message: string;
+        retryable?: boolean | undefined;
+        details?: unknown;
+        stack?: string | undefined;
+    };
+    type: "result";
+    octonode: "1";
+    status: "error";
+    invocationId: string;
+}>;
+/** Node → engine: the outcome of an invocation. */
+export declare const ResultEnvelope: z.ZodDiscriminatedUnion<"status", [z.ZodObject<{
+    octonode: z.ZodLiteral<"1">;
+    type: z.ZodLiteral<"result">;
+    invocationId: z.ZodString;
+    status: z.ZodLiteral<"ok">;
+    outputs: z.ZodUnknown;
+}, "strip", z.ZodTypeAny, {
+    type: "result";
+    octonode: "1";
+    status: "ok";
+    invocationId: string;
+    outputs?: unknown;
+}, {
+    type: "result";
+    octonode: "1";
+    status: "ok";
+    invocationId: string;
+    outputs?: unknown;
+}>, z.ZodObject<{
+    octonode: z.ZodLiteral<"1">;
+    type: z.ZodLiteral<"result">;
+    invocationId: z.ZodString;
+    status: z.ZodLiteral<"error">;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["VALIDATION_ERROR", "RUNTIME_ERROR", "TIMEOUT", "NON_RETRYABLE"]>;
+        message: z.ZodString;
+        retryable: z.ZodDefault<z.ZodBoolean>;
+        details: z.ZodOptional<z.ZodUnknown>;
+        stack: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        code: "VALIDATION_ERROR" | "RUNTIME_ERROR" | "TIMEOUT" | "NON_RETRYABLE";
+        message: string;
+        retryable: boolean;
+        details?: unknown;
+        stack?: string | undefined;
+    }, {
+        code: "VALIDATION_ERROR" | "RUNTIME_ERROR" | "TIMEOUT" | "NON_RETRYABLE";
+        message: string;
+        retryable?: boolean | undefined;
+        details?: unknown;
+        stack?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    error: {
+        code: "VALIDATION_ERROR" | "RUNTIME_ERROR" | "TIMEOUT" | "NON_RETRYABLE";
+        message: string;
+        retryable: boolean;
+        details?: unknown;
+        stack?: string | undefined;
+    };
+    type: "result";
+    octonode: "1";
+    status: "error";
+    invocationId: string;
+}, {
+    error: {
+        code: "VALIDATION_ERROR" | "RUNTIME_ERROR" | "TIMEOUT" | "NON_RETRYABLE";
+        message: string;
+        retryable?: boolean | undefined;
+        details?: unknown;
+        stack?: string | undefined;
+    };
+    type: "result";
+    octonode: "1";
+    status: "error";
+    invocationId: string;
+}>]>;
+export type ResultEnvelope = z.infer<typeof ResultEnvelope>;
+export type OkResult = z.infer<typeof ResultOk>;
+export type ErrorResult = z.infer<typeof ResultErr>;
+/**
+ * What a node declares about itself: a stable id, its language, the JSON Schema
+ * for its inputs and outputs, and optional presentation/runtime seeds. This is
+ * the payload `octonode scan` collects (Phase 3) to populate `.octonode`.
+ */
+export declare const NodeManifest: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    symbol: z.ZodOptional<z.ZodString>;
+    defaults: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    /** A workflow wrapper receives the current execution config through its invocation context. */
+    workflowId: z.ZodOptional<z.ZodString>;
+    language: z.ZodString;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    /**
+     * What this node is: `function` (default), `class`, `service`, or `const`.
+     * Set by the setup-time SDK helpers (defineService/defineClass/defineConst)
+     * so `scan` writes it to `.octonode`.
+     */
+    kind: z.ZodOptional<z.ZodEnum<["function", "class", "service", "const"]>>;
+    /** Setup params for non-function kinds (constructor/config shape). */
+    setup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    /** Advisory default icon — a one-time seed; config owns it thereafter. */
+    icon: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["arrow-up-down", "binary", "bomb", "boxes", "braces", "calculator", "calendar", "camera", "clock", "code", "copy-x", "database", "dices", "filter", "flag", "flask", "function", "git-branch", "git-merge", "group", "hook", "list-filter", "merge", "octagon-x", "package", "package-x", "pencil", "play", "regex", "repeat", "replace", "ruler", "scan-eye", "scissors", "search", "server-cog", "settings", "sigma", "split", "terminal", "test-tube", "text-cursor-input", "ticket", "truck", "type", "typescript", "ungroup", "variable", "wand", "wave", "webhook", "workflow", "x"]>, z.ZodEffects<z.ZodString, string, string>]>>;
+    /** Advisory default config — a one-time seed; config owns it thereafter. */
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    /** Explicit service exposure. Plain classes never populate this field. */
+    service: z.ZodOptional<z.ZodObject<{
+        lifecycle: z.ZodEnum<["invocation", "workflow-run", "worker"]>;
+        methods: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            params: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            params: string[];
+            inputs?: Record<string, unknown> | undefined;
+            outputs?: Record<string, unknown> | undefined;
+        }, {
+            name: string;
+            params?: string[] | undefined;
+            inputs?: Record<string, unknown> | undefined;
+            outputs?: Record<string, unknown> | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        lifecycle: "invocation" | "workflow-run" | "worker";
+        methods: {
+            name: string;
+            params: string[];
+            inputs?: Record<string, unknown> | undefined;
+            outputs?: Record<string, unknown> | undefined;
+        }[];
+    }, {
+        lifecycle: "invocation" | "workflow-run" | "worker";
+        methods: {
+            name: string;
+            params?: string[] | undefined;
+            inputs?: Record<string, unknown> | undefined;
+            outputs?: Record<string, unknown> | undefined;
+        }[];
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    language: string;
+    symbol?: string | undefined;
+    config?: Record<string, unknown> | undefined;
+    service?: {
+        lifecycle: "invocation" | "workflow-run" | "worker";
+        methods: {
+            name: string;
+            params: string[];
+            inputs?: Record<string, unknown> | undefined;
+            outputs?: Record<string, unknown> | undefined;
+        }[];
+    } | undefined;
+    label?: string | undefined;
+    workflowId?: string | undefined;
+    inputs?: Record<string, unknown> | undefined;
+    outputs?: Record<string, unknown> | undefined;
+    description?: string | undefined;
+    defaults?: Record<string, unknown> | undefined;
+    kind?: "function" | "class" | "service" | "const" | undefined;
+    setup?: Record<string, unknown> | undefined;
+    icon?: string | undefined;
+}, {
+    id: string;
+    language: string;
+    symbol?: string | undefined;
+    config?: Record<string, unknown> | undefined;
+    service?: {
+        lifecycle: "invocation" | "workflow-run" | "worker";
+        methods: {
+            name: string;
+            params?: string[] | undefined;
+            inputs?: Record<string, unknown> | undefined;
+            outputs?: Record<string, unknown> | undefined;
+        }[];
+    } | undefined;
+    label?: string | undefined;
+    workflowId?: string | undefined;
+    inputs?: Record<string, unknown> | undefined;
+    outputs?: Record<string, unknown> | undefined;
+    description?: string | undefined;
+    defaults?: Record<string, unknown> | undefined;
+    kind?: "function" | "class" | "service" | "const" | undefined;
+    setup?: Record<string, unknown> | undefined;
+    icon?: string | undefined;
+}>;
+export type NodeManifest = z.infer<typeof NodeManifest>;
+declare const ManifestOk: z.ZodObject<{
+    octonode: z.ZodLiteral<"1">;
+    type: z.ZodLiteral<"manifest">;
+    invocationId: z.ZodString;
+    status: z.ZodLiteral<"ok">;
+    manifest: z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        symbol: z.ZodOptional<z.ZodString>;
+        defaults: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** A workflow wrapper receives the current execution config through its invocation context. */
+        workflowId: z.ZodOptional<z.ZodString>;
+        language: z.ZodString;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /**
+         * What this node is: `function` (default), `class`, `service`, or `const`.
+         * Set by the setup-time SDK helpers (defineService/defineClass/defineConst)
+         * so `scan` writes it to `.octonode`.
+         */
+        kind: z.ZodOptional<z.ZodEnum<["function", "class", "service", "const"]>>;
+        /** Setup params for non-function kinds (constructor/config shape). */
+        setup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** Advisory default icon — a one-time seed; config owns it thereafter. */
+        icon: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["arrow-up-down", "binary", "bomb", "boxes", "braces", "calculator", "calendar", "camera", "clock", "code", "copy-x", "database", "dices", "filter", "flag", "flask", "function", "git-branch", "git-merge", "group", "hook", "list-filter", "merge", "octagon-x", "package", "package-x", "pencil", "play", "regex", "repeat", "replace", "ruler", "scan-eye", "scissors", "search", "server-cog", "settings", "sigma", "split", "terminal", "test-tube", "text-cursor-input", "ticket", "truck", "type", "typescript", "ungroup", "variable", "wand", "wave", "webhook", "workflow", "x"]>, z.ZodEffects<z.ZodString, string, string>]>>;
+        /** Advisory default config — a one-time seed; config owns it thereafter. */
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** Explicit service exposure. Plain classes never populate this field. */
+        service: z.ZodOptional<z.ZodObject<{
+            lifecycle: z.ZodEnum<["invocation", "workflow-run", "worker"]>;
+            methods: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                params: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+                inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                params: string[];
+                inputs?: Record<string, unknown> | undefined;
+                outputs?: Record<string, unknown> | undefined;
+            }, {
+                name: string;
+                params?: string[] | undefined;
+                inputs?: Record<string, unknown> | undefined;
+                outputs?: Record<string, unknown> | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            lifecycle: "invocation" | "workflow-run" | "worker";
+            methods: {
+                name: string;
+                params: string[];
+                inputs?: Record<string, unknown> | undefined;
+                outputs?: Record<string, unknown> | undefined;
+            }[];
+        }, {
+            lifecycle: "invocation" | "workflow-run" | "worker";
+            methods: {
+                name: string;
+                params?: string[] | undefined;
+                inputs?: Record<string, unknown> | undefined;
+                outputs?: Record<string, unknown> | undefined;
+            }[];
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        language: string;
+        symbol?: string | undefined;
+        config?: Record<string, unknown> | undefined;
+        service?: {
+            lifecycle: "invocation" | "workflow-run" | "worker";
+            methods: {
+                name: string;
+                params: string[];
+                inputs?: Record<string, unknown> | undefined;
+                outputs?: Record<string, unknown> | undefined;
+            }[];
+        } | undefined;
+        label?: string | undefined;
+        workflowId?: string | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        outputs?: Record<string, unknown> | undefined;
+        description?: string | undefined;
+        defaults?: Record<string, unknown> | undefined;
+        kind?: "function" | "class" | "service" | "const" | undefined;
+        setup?: Record<string, unknown> | undefined;
+        icon?: string | undefined;
+    }, {
+        id: string;
+        language: string;
+        symbol?: string | undefined;
+        config?: Record<string, unknown> | undefined;
+        service?: {
+            lifecycle: "invocation" | "workflow-run" | "worker";
+            methods: {
+                name: string;
+                params?: string[] | undefined;
+                inputs?: Record<string, unknown> | undefined;
+                outputs?: Record<string, unknown> | undefined;
+            }[];
+        } | undefined;
+        label?: string | undefined;
+        workflowId?: string | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        outputs?: Record<string, unknown> | undefined;
+        description?: string | undefined;
+        defaults?: Record<string, unknown> | undefined;
+        kind?: "function" | "class" | "service" | "const" | undefined;
+        setup?: Record<string, unknown> | undefined;
+        icon?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "manifest";
+    octonode: "1";
+    status: "ok";
+    invocationId: string;
+    manifest: {
+        id: string;
+        language: string;
+        symbol?: string | undefined;
+        config?: Record<string, unknown> | undefined;
+        service?: {
+            lifecycle: "invocation" | "workflow-run" | "worker";
+            methods: {
+                name: string;
+                params: string[];
+                inputs?: Record<string, unknown> | undefined;
+                outputs?: Record<string, unknown> | undefined;
+            }[];
+        } | undefined;
+        label?: string | undefined;
+        workflowId?: string | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        outputs?: Record<string, unknown> | undefined;
+        description?: string | undefined;
+        defaults?: Record<string, unknown> | undefined;
+        kind?: "function" | "class" | "service" | "const" | undefined;
+        setup?: Record<string, unknown> | undefined;
+        icon?: string | undefined;
+    };
+}, {
+    type: "manifest";
+    octonode: "1";
+    status: "ok";
+    invocationId: string;
+    manifest: {
+        id: string;
+        language: string;
+        symbol?: string | undefined;
+        config?: Record<string, unknown> | undefined;
+        service?: {
+            lifecycle: "invocation" | "workflow-run" | "worker";
+            methods: {
+                name: string;
+                params?: string[] | undefined;
+                inputs?: Record<string, unknown> | undefined;
+                outputs?: Record<string, unknown> | undefined;
+            }[];
+        } | undefined;
+        label?: string | undefined;
+        workflowId?: string | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        outputs?: Record<string, unknown> | undefined;
+        description?: string | undefined;
+        defaults?: Record<string, unknown> | undefined;
+        kind?: "function" | "class" | "service" | "const" | undefined;
+        setup?: Record<string, unknown> | undefined;
+        icon?: string | undefined;
+    };
+}>;
+declare const ManifestErr: z.ZodObject<{
+    octonode: z.ZodLiteral<"1">;
+    type: z.ZodLiteral<"manifest">;
+    invocationId: z.ZodString;
+    status: z.ZodLiteral<"error">;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["VALIDATION_ERROR", "RUNTIME_ERROR", "TIMEOUT", "NON_RETRYABLE"]>;
+        message: z.ZodString;
+        retryable: z.ZodDefault<z.ZodBoolean>;
+        details: z.ZodOptional<z.ZodUnknown>;
+        stack: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        code: "VALIDATION_ERROR" | "RUNTIME_ERROR" | "TIMEOUT" | "NON_RETRYABLE";
+        message: string;
+        retryable: boolean;
+        details?: unknown;
+        stack?: string | undefined;
+    }, {
+        code: "VALIDATION_ERROR" | "RUNTIME_ERROR" | "TIMEOUT" | "NON_RETRYABLE";
+        message: string;
+        retryable?: boolean | undefined;
+        details?: unknown;
+        stack?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    error: {
+        code: "VALIDATION_ERROR" | "RUNTIME_ERROR" | "TIMEOUT" | "NON_RETRYABLE";
+        message: string;
+        retryable: boolean;
+        details?: unknown;
+        stack?: string | undefined;
+    };
+    type: "manifest";
+    octonode: "1";
+    status: "error";
+    invocationId: string;
+}, {
+    error: {
+        code: "VALIDATION_ERROR" | "RUNTIME_ERROR" | "TIMEOUT" | "NON_RETRYABLE";
+        message: string;
+        retryable?: boolean | undefined;
+        details?: unknown;
+        stack?: string | undefined;
+    };
+    type: "manifest";
+    octonode: "1";
+    status: "error";
+    invocationId: string;
+}>;
+/** Node → engine: the response to a `describe` request. */
+export declare const ManifestEnvelope: z.ZodDiscriminatedUnion<"status", [z.ZodObject<{
+    octonode: z.ZodLiteral<"1">;
+    type: z.ZodLiteral<"manifest">;
+    invocationId: z.ZodString;
+    status: z.ZodLiteral<"ok">;
+    manifest: z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        symbol: z.ZodOptional<z.ZodString>;
+        defaults: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** A workflow wrapper receives the current execution config through its invocation context. */
+        workflowId: z.ZodOptional<z.ZodString>;
+        language: z.ZodString;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /**
+         * What this node is: `function` (default), `class`, `service`, or `const`.
+         * Set by the setup-time SDK helpers (defineService/defineClass/defineConst)
+         * so `scan` writes it to `.octonode`.
+         */
+        kind: z.ZodOptional<z.ZodEnum<["function", "class", "service", "const"]>>;
+        /** Setup params for non-function kinds (constructor/config shape). */
+        setup: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** Advisory default icon — a one-time seed; config owns it thereafter. */
+        icon: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["arrow-up-down", "binary", "bomb", "boxes", "braces", "calculator", "calendar", "camera", "clock", "code", "copy-x", "database", "dices", "filter", "flag", "flask", "function", "git-branch", "git-merge", "group", "hook", "list-filter", "merge", "octagon-x", "package", "package-x", "pencil", "play", "regex", "repeat", "replace", "ruler", "scan-eye", "scissors", "search", "server-cog", "settings", "sigma", "split", "terminal", "test-tube", "text-cursor-input", "ticket", "truck", "type", "typescript", "ungroup", "variable", "wand", "wave", "webhook", "workflow", "x"]>, z.ZodEffects<z.ZodString, string, string>]>>;
+        /** Advisory default config — a one-time seed; config owns it thereafter. */
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** Explicit service exposure. Plain classes never populate this field. */
+        service: z.ZodOptional<z.ZodObject<{
+            lifecycle: z.ZodEnum<["invocation", "workflow-run", "worker"]>;
+            methods: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                params: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+                inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                params: string[];
+                inputs?: Record<string, unknown> | undefined;
+                outputs?: Record<string, unknown> | undefined;
+            }, {
+                name: string;
+                params?: string[] | undefined;
+                inputs?: Record<string, unknown> | undefined;
+                outputs?: Record<string, unknown> | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            lifecycle: "invocation" | "workflow-run" | "worker";
+            methods: {
+                name: string;
+                params: string[];
+                inputs?: Record<string, unknown> | undefined;
+                outputs?: Record<string, unknown> | undefined;
+            }[];
+        }, {
+            lifecycle: "invocation" | "workflow-run" | "worker";
+            methods: {
+                name: string;
+                params?: string[] | undefined;
+                inputs?: Record<string, unknown> | undefined;
+                outputs?: Record<string, unknown> | undefined;
+            }[];
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        language: string;
+        symbol?: string | undefined;
+        config?: Record<string, unknown> | undefined;
+        service?: {
+            lifecycle: "invocation" | "workflow-run" | "worker";
+            methods: {
+                name: string;
+                params: string[];
+                inputs?: Record<string, unknown> | undefined;
+                outputs?: Record<string, unknown> | undefined;
+            }[];
+        } | undefined;
+        label?: string | undefined;
+        workflowId?: string | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        outputs?: Record<string, unknown> | undefined;
+        description?: string | undefined;
+        defaults?: Record<string, unknown> | undefined;
+        kind?: "function" | "class" | "service" | "const" | undefined;
+        setup?: Record<string, unknown> | undefined;
+        icon?: string | undefined;
+    }, {
+        id: string;
+        language: string;
+        symbol?: string | undefined;
+        config?: Record<string, unknown> | undefined;
+        service?: {
+            lifecycle: "invocation" | "workflow-run" | "worker";
+            methods: {
+                name: string;
+                params?: string[] | undefined;
+                inputs?: Record<string, unknown> | undefined;
+                outputs?: Record<string, unknown> | undefined;
+            }[];
+        } | undefined;
+        label?: string | undefined;
+        workflowId?: string | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        outputs?: Record<string, unknown> | undefined;
+        description?: string | undefined;
+        defaults?: Record<string, unknown> | undefined;
+        kind?: "function" | "class" | "service" | "const" | undefined;
+        setup?: Record<string, unknown> | undefined;
+        icon?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "manifest";
+    octonode: "1";
+    status: "ok";
+    invocationId: string;
+    manifest: {
+        id: string;
+        language: string;
+        symbol?: string | undefined;
+        config?: Record<string, unknown> | undefined;
+        service?: {
+            lifecycle: "invocation" | "workflow-run" | "worker";
+            methods: {
+                name: string;
+                params: string[];
+                inputs?: Record<string, unknown> | undefined;
+                outputs?: Record<string, unknown> | undefined;
+            }[];
+        } | undefined;
+        label?: string | undefined;
+        workflowId?: string | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        outputs?: Record<string, unknown> | undefined;
+        description?: string | undefined;
+        defaults?: Record<string, unknown> | undefined;
+        kind?: "function" | "class" | "service" | "const" | undefined;
+        setup?: Record<string, unknown> | undefined;
+        icon?: string | undefined;
+    };
+}, {
+    type: "manifest";
+    octonode: "1";
+    status: "ok";
+    invocationId: string;
+    manifest: {
+        id: string;
+        language: string;
+        symbol?: string | undefined;
+        config?: Record<string, unknown> | undefined;
+        service?: {
+            lifecycle: "invocation" | "workflow-run" | "worker";
+            methods: {
+                name: string;
+                params?: string[] | undefined;
+                inputs?: Record<string, unknown> | undefined;
+                outputs?: Record<string, unknown> | undefined;
+            }[];
+        } | undefined;
+        label?: string | undefined;
+        workflowId?: string | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        outputs?: Record<string, unknown> | undefined;
+        description?: string | undefined;
+        defaults?: Record<string, unknown> | undefined;
+        kind?: "function" | "class" | "service" | "const" | undefined;
+        setup?: Record<string, unknown> | undefined;
+        icon?: string | undefined;
+    };
+}>, z.ZodObject<{
+    octonode: z.ZodLiteral<"1">;
+    type: z.ZodLiteral<"manifest">;
+    invocationId: z.ZodString;
+    status: z.ZodLiteral<"error">;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["VALIDATION_ERROR", "RUNTIME_ERROR", "TIMEOUT", "NON_RETRYABLE"]>;
+        message: z.ZodString;
+        retryable: z.ZodDefault<z.ZodBoolean>;
+        details: z.ZodOptional<z.ZodUnknown>;
+        stack: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        code: "VALIDATION_ERROR" | "RUNTIME_ERROR" | "TIMEOUT" | "NON_RETRYABLE";
+        message: string;
+        retryable: boolean;
+        details?: unknown;
+        stack?: string | undefined;
+    }, {
+        code: "VALIDATION_ERROR" | "RUNTIME_ERROR" | "TIMEOUT" | "NON_RETRYABLE";
+        message: string;
+        retryable?: boolean | undefined;
+        details?: unknown;
+        stack?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    error: {
+        code: "VALIDATION_ERROR" | "RUNTIME_ERROR" | "TIMEOUT" | "NON_RETRYABLE";
+        message: string;
+        retryable: boolean;
+        details?: unknown;
+        stack?: string | undefined;
+    };
+    type: "manifest";
+    octonode: "1";
+    status: "error";
+    invocationId: string;
+}, {
+    error: {
+        code: "VALIDATION_ERROR" | "RUNTIME_ERROR" | "TIMEOUT" | "NON_RETRYABLE";
+        message: string;
+        retryable?: boolean | undefined;
+        details?: unknown;
+        stack?: string | undefined;
+    };
+    type: "manifest";
+    octonode: "1";
+    status: "error";
+    invocationId: string;
+}>]>;
+export type ManifestEnvelope = z.infer<typeof ManifestEnvelope>;
+export type ManifestResult = z.infer<typeof ManifestOk>;
+export type ManifestError = z.infer<typeof ManifestErr>;
+export declare function makeInvokeRequest(args: {
+    invocationId: string;
+    inputs: unknown;
+    node?: string;
+    context?: Partial<InvocationContext>;
+}): InvokeRequest;
+export declare function makeDescribeRequest(args: {
+    invocationId: string;
+    node?: string;
+}): DescribeRequest;
+export declare function makeOkResult(invocationId: string, outputs: unknown): OkResult;
+export declare function makeErrorResult(invocationId: string, error: NodeError): ErrorResult;
+export declare function makeManifestResult(invocationId: string, manifest: NodeManifest): ManifestResult;
+export declare function makeManifestError(invocationId: string, error: NodeError): ManifestError;
+export {};
+//# sourceMappingURL=envelope.d.ts.map