@mininglamp-oss/octo-runtime 0.0.0-stage → 1.0.0

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/invoke-input.d.ts

@@ -0,0 +1,120 @@
+import { type AgentConfig, type AgentSource, type ApprovalMode, type CanonicalEvent, type ContextEnvelope, type ContextEnvsPayload, type HostFrame, type InvokeRequest, type ModelInputPart, type ProviderSession, type RuntimeLimits } from "./index.js";
+/**
+ * Public JSON invocation contract shared by CLI, SDK and channels.
+ * A plain JSON object satisfies this class structurally; `new` is not required.
+ * Only inputs and contexts are required. Defaults are resolved by the execution
+ * boundary, never by adding historical business context.
+ */
+export declare class InvokeInput {
+    /** Exact current-turn text/image parts, in caller order. Image bytes occur here once. */
+    inputs: ModelInputPart[];
+    /** Caller-owned Context v3 snapshot; an empty items array is valid. */
+    contexts: ContextEnvelope;
+    /** Business session identity; generated if omitted. Does not imply provider resume. */
+    sessionId?: string;
+    /** Output view of the same execution stream; defaults to native. */
+    protocol_mode?: "native" | "canonical";
+    /** Cancellation identity for this invocation; generated if omitted. */
+    invocationId?: string;
+    /** Business Run identity; generated if omitted. Independent of invocation/session IDs. */
+    runId?: string;
+    /** Caller-owned session generation, used to fence stale updates; no inferred default. */
+    sessionGeneration?: number;
+    /** Caller-owned provider binding epoch; no inferred default. */
+    providerEpoch?: number;
+    /** Agent ownership: preset for OpenClaw by default, provisioned otherwise. */
+    agentSource?: AgentSource;
+    /** Display-safe description; defaults to the textual summary of inputs. */
+    prompt?: string;
+    /** Exact textual provider turn when distinct from the multipart inputs summary. */
+    modelInput?: string;
+    /** Provider cwd; defaults to the resolved workspace (local cwd when omitted). */
+    workdir?: string;
+    /** Trusted instructions, separate from model business context; derived if omitted. */
+    controlInstructions?: string;
+    /** Execution approval policy, normally resolved from contexts; defaults to ask. */
+    approvalMode?: ApprovalMode;
+    /** Full provider configuration, including providerOptions; context selections must agree. */
+    agentConfig?: AgentConfig;
+    /** Complete timeout/enforcement settings; execution defaults apply when omitted. */
+    runtimeLimits?: RuntimeLimits;
+    /** JSON metadata for tracing/business identity; not model text or authorization evidence. */
+    runMetadata?: Record<string, unknown>;
+    /** Opaque provider session, including provider extension fields; never rebuilt from sessionId. */
+    providerSession?: ProviderSession;
+    /** Fresh/continue intent; defaults to continue with providerSession, fresh otherwise. */
+    continuityMode?: "fresh" | "continue";
+    /** Caller-provided exact recovery text; no automatic history reconstruction. */
+    freshFallbackModelInput?: string;
+    /** Caller-provided recovery text/image parts; recovery images must be supplied explicitly. */
+    freshFallbackModelInputParts?: ModelInputPart[];
+    /** Explicitly fail fresh fallback when historical image bytes cannot be supplied. */
+    freshFallbackImagesUnavailable?: boolean;
+    /** Checks the JSON boundary; resolved execution additionally uses assertInvokeRequest. */
+    static check(value: unknown): InvokeInput;
+}
+/** Local ingress execution settings, outside caller-owned JSON and Context. */
+export interface InvokeEnvironment {
+    signal?: AbortSignal;
+    /** Trusted per-invocation values; forwarded privately across the Host process boundary. */
+    executionEnvOverrides?: ContextEnvsPayload;
+}
+export type InputFrames = (input: InvokeInput, environment?: InvokeEnvironment) => AsyncGenerator<HostFrame>;
+/** Stable correlation IDs for cancellation and stream reconnection, without resolving execution. */
+export declare function identifyInvokeInput(input: InvokeInput): {
+    invocationId: string;
+    runId: string;
+    sessionId: string;
+    /** Exact current-turn text/image parts, in caller order. Image bytes occur here once. */
+    inputs: ModelInputPart[];
+    /** Caller-owned Context v3 snapshot; an empty items array is valid. */
+    contexts: ContextEnvelope;
+    /** Output view of the same execution stream; defaults to native. */
+    protocol_mode?: "native" | "canonical";
+    /** Caller-owned session generation, used to fence stale updates; no inferred default. */
+    sessionGeneration?: number;
+    /** Caller-owned provider binding epoch; no inferred default. */
+    providerEpoch?: number;
+    /** Agent ownership: preset for OpenClaw by default, provisioned otherwise. */
+    agentSource?: AgentSource;
+    /** Display-safe description; defaults to the textual summary of inputs. */
+    prompt?: string;
+    /** Exact textual provider turn when distinct from the multipart inputs summary. */
+    modelInput?: string;
+    /** Provider cwd; defaults to the resolved workspace (local cwd when omitted). */
+    workdir?: string;
+    /** Trusted instructions, separate from model business context; derived if omitted. */
+    controlInstructions?: string;
+    /** Execution approval policy, normally resolved from contexts; defaults to ask. */
+    approvalMode?: ApprovalMode;
+    /** Full provider configuration, including providerOptions; context selections must agree. */
+    agentConfig?: AgentConfig;
+    /** Complete timeout/enforcement settings; execution defaults apply when omitted. */
+    runtimeLimits?: RuntimeLimits;
+    /** JSON metadata for tracing/business identity; not model text or authorization evidence. */
+    runMetadata?: Record<string, unknown>;
+    /** Opaque provider session, including provider extension fields; never rebuilt from sessionId. */
+    providerSession?: ProviderSession;
+    /** Fresh/continue intent; defaults to continue with providerSession, fresh otherwise. */
+    continuityMode?: "fresh" | "continue";
+    /** Caller-provided exact recovery text; no automatic history reconstruction. */
+    freshFallbackModelInput?: string;
+    /** Caller-provided recovery text/image parts; recovery images must be supplied explicitly. */
+    freshFallbackModelInputParts?: ModelInputPart[];
+    /** Explicitly fail fresh fallback when historical image bytes cannot be supplied. */
+    freshFallbackImagesUnavailable?: boolean;
+};
+/** Select a view of one source stream; execution preparation belongs to the Host. */
+export declare function createInputInvoke(source: InputFrames): InputInvoke;
+export interface InputInvoke {
+    (input: InvokeInput & {
+        protocol_mode: "canonical";
+    }, environment?: InvokeEnvironment): AsyncGenerator<CanonicalEvent>;
+    (input: InvokeInput & {
+        protocol_mode?: "native";
+    }, environment?: InvokeEnvironment): AsyncGenerator<HostFrame>;
+    (input: InvokeInput, environment?: InvokeEnvironment): AsyncGenerator<CanonicalEvent | HostFrame>;
+}
+export declare function assertInvokeInput(value: unknown): asserts value is InvokeInput;
+/** Lossless field reorganization of a validated prepared execution, excluding its local signal. */
+export declare function invocationInput(request: InvokeRequest, protocol_mode?: "native" | "canonical", adapterType?: string): InvokeInput;

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/invoke-input.js

@@ -0,0 +1,164 @@
+import { assertAgentSource, assertApprovalMode, assertContextEnvelope, assertModelInputParts, assertRuntimeLimits } from "./index.js";
+import { assertJsonValue } from "./context.js";
+import { canonicalEvents } from "./run-protocol.js";
+import { assertJsonByteLimit } from "./json-size.js";
+import { INVOKE_REQUEST_MAX_BYTES } from "./invoke-size.js";
+/**
+ * Public JSON invocation contract shared by CLI, SDK and channels.
+ * A plain JSON object satisfies this class structurally; `new` is not required.
+ * Only inputs and contexts are required. Defaults are resolved by the execution
+ * boundary, never by adding historical business context.
+ */
+export class InvokeInput {
+    /** Checks the JSON boundary; resolved execution additionally uses assertInvokeRequest. */
+    static check(value) {
+        assertInvokeInput(value);
+        return value;
+    }
+}
+/** Stable correlation IDs for cancellation and stream reconnection, without resolving execution. */
+export function identifyInvokeInput(input) {
+    return {
+        ...input,
+        invocationId: input.invocationId ?? globalThis.crypto.randomUUID(),
+        runId: input.runId ?? globalThis.crypto.randomUUID(),
+        sessionId: input.sessionId ?? globalThis.crypto.randomUUID()
+    };
+}
+/** Select a view of one source stream; execution preparation belongs to the Host. */
+export function createInputInvoke(source) {
+    return async function* (input, environment) {
+        environment?.signal?.throwIfAborted();
+        const frames = source(input, environment);
+        try {
+            if (input.protocol_mode === "canonical")
+                yield* canonicalEvents(frames);
+            else
+                yield* frames;
+        }
+        finally {
+            environment?.signal?.throwIfAborted();
+        }
+    };
+}
+export function assertInvokeInput(value) {
+    assertJsonByteLimit(value instanceof InvokeInput ? { ...value } : value, INVOKE_REQUEST_MAX_BYTES, "INVOKE_REQUEST_TOO_LARGE");
+    assertJsonValue(value);
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new TypeError("InvokeInput must be a JSON object");
+    const input = value;
+    if (["protocolMode", "adapterType", "request", "options"].some((key) => Object.hasOwn(input, key)))
+        throw new TypeError("InvokeInput requires the unified JSON contract, not a prepared request wrapper");
+    if (Object.hasOwn(input, "signal"))
+        throw new TypeError("signal belongs to the local invoke environment");
+    if (Object.hasOwn(input, "executionEnvOverrides"))
+        throw new TypeError("executionEnvOverrides belongs to the local invoke environment");
+    assertModelInputParts(input.inputs);
+    assertContextEnvelope(input.contexts);
+    for (const key of [
+        "sessionId",
+        "invocationId",
+        "runId",
+        "prompt",
+        "modelInput",
+        "freshFallbackModelInput"
+    ])
+        if (input[key] !== undefined && (typeof input[key] !== "string" || !input[key]))
+            throw new TypeError(`InvokeInput.${key} must be a non-empty string`);
+    for (const key of ["workdir", "controlInstructions"])
+        if (input[key] !== undefined && typeof input[key] !== "string")
+            throw new TypeError(`InvokeInput.${key} must be a string`);
+    for (const key of ["sessionGeneration", "providerEpoch"])
+        if (input[key] !== undefined &&
+            (!Number.isSafeInteger(input[key]) || input[key] < 0))
+            throw new TypeError(`InvokeInput.${key} must be a non-negative safe integer`);
+    if (input.protocol_mode !== undefined &&
+        !["native", "canonical"].includes(input.protocol_mode))
+        throw new TypeError("protocol_mode must be native or canonical");
+    if (input.agentSource !== undefined)
+        assertAgentSource(input.agentSource);
+    if (input.approvalMode !== undefined)
+        assertApprovalMode(input.approvalMode);
+    if (input.continuityMode !== undefined &&
+        !["fresh", "continue"].includes(input.continuityMode))
+        throw new TypeError("continuityMode must be fresh or continue");
+    if (input.runtimeLimits !== undefined)
+        assertRuntimeLimits(input.runtimeLimits);
+    if (input.freshFallbackModelInputParts !== undefined)
+        assertModelInputParts(input.freshFallbackModelInputParts);
+    if (input.freshFallbackImagesUnavailable !== undefined &&
+        typeof input.freshFallbackImagesUnavailable !== "boolean")
+        throw new TypeError("freshFallbackImagesUnavailable must be a boolean");
+    for (const key of ["agentConfig", "runMetadata", "providerSession"])
+        if (input[key] !== undefined &&
+            (!input[key] || typeof input[key] !== "object" || Array.isArray(input[key])))
+            throw new TypeError(`InvokeInput.${key} must be a JSON object`);
+    if (input.agentConfig) {
+        const config = input.agentConfig;
+        for (const key of [
+            "workdir",
+            "model",
+            "sandbox",
+            "providerAgentId",
+            "effort",
+            "openclawConfigPath",
+            "openclawStateDir"
+        ])
+            if (config[key] !== undefined && typeof config[key] !== "string")
+                throw new TypeError(`agentConfig.${key} must be a string`);
+        if (config.timeoutSeconds !== undefined &&
+            (typeof config.timeoutSeconds !== "number" || config.timeoutSeconds <= 0))
+            throw new TypeError("agentConfig.timeoutSeconds must be positive");
+        if (config.providerOptions !== undefined &&
+            (!config.providerOptions ||
+                typeof config.providerOptions !== "object" ||
+                Array.isArray(config.providerOptions)))
+            throw new TypeError("agentConfig.providerOptions must be a JSON object");
+    }
+    if (input.providerSession) {
+        const session = input.providerSession;
+        if (typeof session.sessionId !== "string" || !session.sessionId.trim())
+            throw new TypeError("providerSession.sessionId must be a non-empty string");
+        if (session.resumable !== undefined && typeof session.resumable !== "boolean")
+            throw new TypeError("providerSession.resumable must be a boolean");
+        if (session.resumeOutcome !== undefined &&
+            !["new", "resumed", "fresh_fallback", "compacted"].includes(session.resumeOutcome))
+            throw new TypeError("providerSession.resumeOutcome is invalid");
+        if (session.resumeFallback !== undefined && typeof session.resumeFallback !== "string")
+            throw new TypeError("providerSession.resumeFallback must be a string");
+        if (session.contextInputVariant !== undefined &&
+            !["primary", "recovery"].includes(session.contextInputVariant))
+            throw new TypeError("providerSession.contextInputVariant is invalid");
+    }
+}
+/** Lossless field reorganization of a validated prepared execution, excluding its local signal. */
+export function invocationInput(request, protocol_mode = "native", adapterType) {
+    const { protocolVersion: _version, signal: _signal, executionEnvOverrides: _executionEnvOverrides, agentSessionId, context, modelInputParts, ...fields } = request;
+    void _version;
+    void _signal;
+    void _executionEnvOverrides;
+    const contexts = structuredClone(context);
+    if (adapterType) {
+        const adapter = contexts.items.find((item) => item.namespace === "octo.execution" && item.name === "adapter");
+        if (adapter && adapter.payload.type !== adapterType)
+            throw new TypeError("CONTEXT_PLAN_MISMATCH");
+        if (!adapter)
+            contexts.items.push({
+                namespace: "octo.execution",
+                name: "adapter",
+                payload: {
+                    type: adapterType,
+                    ...(adapterType === "openclaw"
+                        ? { provider_agent_id: request.agentConfig.providerAgentId ?? "main" }
+                        : {})
+                }
+            });
+    }
+    return InvokeInput.check({
+        ...fields,
+        sessionId: agentSessionId,
+        contexts,
+        protocol_mode,
+        inputs: modelInputParts ?? [{ type: "text", text: request.modelInput }]
+    });
+}

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/invoke-size.d.ts

@@ -0,0 +1,3 @@
+import type { InvokeInput, InvokeEnvironment } from "./invoke-input.js";
+export declare const INVOKE_REQUEST_MAX_BYTES: number;
+export declare function assertInvokeRequestSize(input: InvokeInput, environment?: InvokeEnvironment): void;

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/invoke-size.js

@@ -0,0 +1,10 @@
+import { assertJsonByteLimit } from "./json-size.js";
+export const INVOKE_REQUEST_MAX_BYTES = 32 * 1024 * 1024;
+export function assertInvokeRequestSize(input, environment = {}) {
+    assertJsonByteLimit({
+        input: { ...input },
+        ...(environment.executionEnvOverrides
+            ? { executionEnvOverrides: environment.executionEnvOverrides }
+            : {})
+    }, INVOKE_REQUEST_MAX_BYTES, "INVOKE_REQUEST_TOO_LARGE");
+}

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/json-size.d.ts

@@ -0,0 +1,2 @@
+/** Count JSON bytes without allocating the complete serialized input. */
+export declare function assertJsonByteLimit(value: unknown, limit: number, code: string): void;

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/json-size.js

@@ -0,0 +1,91 @@
+/** Count JSON bytes without allocating the complete serialized input. */
+export function assertJsonByteLimit(value, limit, code) {
+    let bytes = 0;
+    const parents = new Set();
+    const add = (count) => {
+        bytes += count;
+        if (bytes > limit)
+            throw Object.assign(new Error(code), { code });
+    };
+    const string = (text) => {
+        add(2);
+        for (let i = 0; i < text.length; i++) {
+            const char = text.charCodeAt(i);
+            if (char === 34 || char === 92 || [8, 9, 10, 12, 13].includes(char))
+                add(2);
+            else if (char < 32)
+                add(6);
+            else if (char < 128)
+                add(1);
+            else if (char < 2048)
+                add(2);
+            else if (char >= 0xd800 && char <= 0xdbff) {
+                const low = text.charCodeAt(i + 1);
+                if (low >= 0xdc00 && low <= 0xdfff) {
+                    add(4);
+                    i++;
+                }
+                else
+                    add(6);
+            }
+            else if (char >= 0xdc00 && char <= 0xdfff)
+                add(6);
+            else
+                add(3);
+        }
+    };
+    const visit = (item, depth) => {
+        if (depth > 64)
+            throw new TypeError("JSON_DEPTH_EXCEEDED");
+        if (typeof item === "string") {
+            string(item);
+            return;
+        }
+        if (item === null || typeof item === "boolean" || typeof item === "number") {
+            add(JSON.stringify(item).length);
+            return;
+        }
+        if (typeof item !== "object")
+            throw new TypeError("JSON_VALUE_REQUIRED");
+        if (parents.has(item))
+            throw new TypeError("JSON_CIRCULAR_REFERENCE");
+        const array = Array.isArray(item);
+        if (!array &&
+            Object.getPrototypeOf(item) !== Object.prototype &&
+            Object.getPrototypeOf(item) !== null)
+            throw new TypeError("JSON_OBJECT_REQUIRED");
+        parents.add(item);
+        add(2);
+        let first = true;
+        if (array) {
+            for (let i = 0; i < item.length; i++) {
+                const descriptor = Object.getOwnPropertyDescriptor(item, String(i));
+                if (descriptor && !("value" in descriptor))
+                    throw new TypeError("JSON_ACCESSOR_UNSUPPORTED");
+                if (!first)
+                    add(1);
+                first = false;
+                visit(descriptor?.value ?? null, depth + 1);
+            }
+        }
+        else {
+            for (const key in item) {
+                const descriptor = Object.getOwnPropertyDescriptor(item, key);
+                if (!descriptor)
+                    continue;
+                if (!("value" in descriptor))
+                    throw new TypeError("JSON_ACCESSOR_UNSUPPORTED");
+                if (descriptor.value === undefined)
+                    continue;
+                if (!first)
+                    add(1);
+                first = false;
+                string(key);
+                add(1);
+                visit(descriptor.value, depth + 1);
+            }
+        }
+        parents.delete(item);
+    };
+    visit(value, 0);
+}

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/model-context.d.ts

@@ -0,0 +1,3 @@
+import type { ContextEnvelope } from "./generated/protocol-types.js";
+/** Sources are validated by the producer's authorization boundary, not by rendering. */
+export declare function contextControlInstructions(context: ContextEnvelope): string;

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/model-context.js

@@ -0,0 +1,9 @@
+import { assertContextEnvelope, contextItem } from "./context.js";
+/** Sources are validated by the producer's authorization boundary, not by rendering. */
+export function contextControlInstructions(context) {
+    assertContextEnvelope(context);
+    const entries = contextItem(context, "octo.control", "instructions")?.payload.entries;
+    return Array.isArray(entries)
+        ? entries.map((entry) => entry.text).join("\n")
+        : "";
+}

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/multimodal.d.ts

@@ -0,0 +1,15 @@
+import type { InvokeRequestWire, ModelInputPart } from "./generated/protocol-types.js";
+export declare const IMAGE_INPUT_LIMITS: Readonly<{
+    maxCount: 4;
+    maxBytes: number;
+    maxTotalBytes: number;
+}>;
+export declare const IMAGE_INPUT_MIME_TYPES: readonly ["image/png", "image/jpeg", "image/webp"];
+export declare function assertModelInputParts(value: unknown): asserts value is ModelInputPart[];
+/** Never fall back to the display string when an invocation contains images. */
+export declare function providerInputParts(request: InvokeRequestWire, freshFallback?: boolean): ModelInputPart[];
+/** Current-turn images must survive recovery, even when historical images are prepended. */
+export declare function assertImageRecoveryParts(request: Pick<InvokeRequestWire, "modelInputParts" | "freshFallbackModelInputParts" | "freshFallbackModelInput">): void;
+export declare function hasImageInput(request: Pick<InvokeRequestWire, "modelInputParts" | "freshFallbackModelInputParts">): boolean;
+/** Artifact sources must already have been fetched under the Run's authorization. */
+export declare function modelPartsFromInput(input: Record<string, unknown>, prefix?: string): ModelInputPart[] | undefined;

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/multimodal.js

@@ -0,0 +1,166 @@
+import { createHash } from "node:crypto";
+export const IMAGE_INPUT_LIMITS = Object.freeze({
+    maxCount: 4,
+    maxBytes: 2 * 1024 * 1024,
+    maxTotalBytes: 8 * 1024 * 1024
+});
+export const IMAGE_INPUT_MIME_TYPES = Object.freeze([
+    "image/png",
+    "image/jpeg",
+    "image/webp"
+]);
+function record(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new TypeError("INPUT_PART_INVALID");
+    return value;
+}
+export function assertModelInputParts(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 128)
+        throw new TypeError("INPUT_PARTS_INVALID");
+    let count = 0;
+    let total = 0;
+    const ids = new Set();
+    for (const item of value) {
+        const part = record(item);
+        if (part.id !== undefined && (typeof part.id !== "string" || !part.id))
+            throw new TypeError("INPUT_PART_INVALID");
+        if (typeof part.id === "string") {
+            if (ids.has(part.id))
+                throw new TypeError("INPUT_PART_INVALID");
+            ids.add(part.id);
+        }
+        const allowed = part.type === "text"
+            ? ["id", "type", "text"]
+            : ["id", "type", "mimeType", "data", "byteSize", "sha256"];
+        if (Object.keys(part).some((key) => !allowed.includes(key)))
+            throw new TypeError("INPUT_PART_INVALID");
+        if (part.type === "text") {
+            if (typeof part.text !== "string")
+                throw new TypeError("INPUT_PART_INVALID");
+            continue;
+        }
+        if (part.type !== "image")
+            throw new TypeError("UNSUPPORTED_INPUT_MODALITY");
+        if (!IMAGE_INPUT_MIME_TYPES.includes(part.mimeType))
+            throw new TypeError("UNSUPPORTED_INPUT_MODALITY");
+        if (!Number.isSafeInteger(part.byteSize) ||
+            Number(part.byteSize) < 1 ||
+            Number(part.byteSize) > IMAGE_INPUT_LIMITS.maxBytes ||
+            typeof part.data !== "string" ||
+            part.data.length > Math.ceil(IMAGE_INPUT_LIMITS.maxBytes / 3) * 4)
+            throw new TypeError("IMAGE_LIMIT_EXCEEDED");
+        if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(part.data))
+            throw new TypeError("ARTIFACT_INTEGRITY_MISMATCH");
+        const bytes = Buffer.from(part.data, "base64");
+        if (bytes.length !== part.byteSize ||
+            bytes.toString("base64") !== part.data ||
+            typeof part.sha256 !== "string" ||
+            !/^[a-f0-9]{64}$/.test(part.sha256) ||
+            createHash("sha256").update(bytes).digest("hex") !== part.sha256)
+            throw new TypeError("ARTIFACT_INTEGRITY_MISMATCH");
+        const validHeader = part.mimeType === "image/png"
+            ? bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))
+            : part.mimeType === "image/jpeg"
+                ? bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff
+                : bytes.subarray(0, 4).toString("ascii") === "RIFF" &&
+                    bytes.subarray(8, 12).toString("ascii") === "WEBP";
+        if (!validHeader)
+            throw new TypeError("ARTIFACT_INTEGRITY_MISMATCH");
+        count += 1;
+        total += bytes.length;
+        if (count > IMAGE_INPUT_LIMITS.maxCount || total > IMAGE_INPUT_LIMITS.maxTotalBytes)
+            throw new TypeError("IMAGE_LIMIT_EXCEEDED");
+    }
+}
+/** Never fall back to the display string when an invocation contains images. */
+export function providerInputParts(request, freshFallback = false) {
+    if (freshFallback && request.freshFallbackImagesUnavailable)
+        throw new TypeError("ARTIFACT_UNAVAILABLE: historical images cannot be restored");
+    assertImageRecoveryParts(request);
+    const parts = freshFallback
+        ? (request.freshFallbackModelInputParts ?? request.modelInputParts)
+        : request.modelInputParts;
+    if (parts) {
+        assertModelInputParts(parts);
+        return structuredClone(parts);
+    }
+    return [
+        {
+            type: "text",
+            text: freshFallback
+                ? (request.freshFallbackModelInput ?? request.modelInput)
+                : request.modelInput
+        }
+    ];
+}
+/** Current-turn images must survive recovery, even when historical images are prepended. */
+export function assertImageRecoveryParts(request) {
+    const current = request.modelInputParts?.filter((part) => part.type === "image") ?? [];
+    if (!current.length)
+        return;
+    if (request.freshFallbackModelInput !== undefined &&
+        request.freshFallbackModelInputParts === undefined)
+        throw new TypeError("IMAGE_RECOVERY_INPUT_REQUIRED");
+    if (request.freshFallbackModelInputParts === undefined)
+        return;
+    const recovery = request.freshFallbackModelInputParts.filter((part) => part.type === "image");
+    const key = (part) => part.id ?? `${part.mimeType}:${part.byteSize}:${part.sha256}`;
+    for (const part of current) {
+        if (current.filter((item) => key(item) === key(part)).length !==
+            recovery.filter((item) => key(item) === key(part)).length)
+            throw new TypeError("IMAGE_RECOVERY_INPUT_REQUIRED");
+    }
+    let index = 0;
+    for (const part of recovery) {
+        const expected = current[index];
+        if (expected &&
+            expected.sha256 === part.sha256 &&
+            expected.byteSize === part.byteSize &&
+            expected.mimeType === part.mimeType &&
+            (expected.id === undefined || expected.id === part.id))
+            index += 1;
+    }
+    if (index !== current.length)
+        throw new TypeError("IMAGE_RECOVERY_INPUT_REQUIRED");
+}
+export function hasImageInput(request) {
+    return [...(request.modelInputParts ?? []), ...(request.freshFallbackModelInputParts ?? [])].some((part) => part.type === "image");
+}
+/** Artifact sources must already have been fetched under the Run's authorization. */
+export function modelPartsFromInput(input, prefix = "") {
+    const parts = Array.isArray(input.parts) ? input.parts : [];
+    if (!parts.some((part) => part && typeof part === "object" && part.type === "image"))
+        return undefined;
+    const output = prefix ? [{ type: "text", text: prefix }] : [];
+    for (const value of parts) {
+        const part = record(value);
+        const id = typeof part.id === "string" ? { id: part.id } : {};
+        if (part.type === "text") {
+            if (typeof part.text !== "string")
+                throw new TypeError("INPUT_PART_INVALID");
+            output.push({ type: "text", text: part.text, ...id });
+        }
+        else if (part.type === "image") {
+            if (!part.source)
+                throw new TypeError("ARTIFACT_UNAVAILABLE");
+            const source = record(part.source);
+            if (Object.keys(source).some((key) => !["mimeType", "data", "byteSize", "sha256"].includes(key)))
+                throw new TypeError("INPUT_PART_INVALID");
+            const image = { ...source, type: "image", ...id };
+            assertModelInputParts([image]);
+            if (part.artifact !== undefined) {
+                const artifact = record(part.artifact);
+                if (artifact.mediaType !== source.mimeType ||
+                    artifact.byteSize !== source.byteSize ||
+                    artifact.sha256 !== source.sha256)
+                    throw new TypeError("ARTIFACT_INTEGRITY_MISMATCH");
+            }
+            output.push(image);
+        }
+        else {
+            throw new TypeError("UNSUPPORTED_INPUT_MODALITY");
+        }
+    }
+    assertModelInputParts(output);
+    return output;
+}

package/node_modules/@mininglamp-oss/octo-runtime-protocol/dist/notification.d.ts

@@ -0,0 +1,2 @@
+import type { NotificationMessage } from "./generated/protocol-types.js";
+export declare function assertNotificationMessage(value: unknown): asserts value is NotificationMessage;