@mininglamp-oss/octo-runtime-client 0.0.0-stage → 1.1.11

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

@@ -0,0 +1,137 @@
+const keys = [
+    "schema",
+    "eventId",
+    "event",
+    "occurredAt",
+    "projectId",
+    "sourceId",
+    "title",
+    "text"
+];
+const events = new Set([
+    "task.event",
+    "execution.succeeded",
+    "execution.failed",
+    "notification.test"
+]);
+const taskIds = [
+    "evt_type",
+    "task",
+    "taskEvent",
+    "timeline",
+    "timelineTruncated",
+    "timelineThroughSequence"
+];
+export function assertNotificationMessage(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("notification must be an object");
+    const message = value;
+    if (Object.keys(message).some((key) => !keys.includes(key) && !taskIds.includes(key)) ||
+        keys.some((key) => typeof message[key] !== "string")) {
+        throw new Error("notification contains missing or unsupported fields");
+    }
+    for (const key of keys) {
+        for (const scalar of message[key]) {
+            const code = scalar.codePointAt(0);
+            if (code >= 0xd800 && code <= 0xdfff)
+                throw new Error("notification contains an unpaired surrogate");
+        }
+    }
+    if (message.schema !== "octo.notification.v2" || !events.has(message.event))
+        throw new Error("unsupported notification schema or event");
+    if (message.event === "task.event") {
+        validateTaskNotification(message);
+    }
+    else if (taskIds.some((key) => key in message)) {
+        throw new Error("task fields require a task event");
+    }
+    for (const [key, max, min] of [
+        ["eventId", 256, 1],
+        ["projectId", 128, 1],
+        ["sourceId", 128, 1],
+        ["title", 256, 1],
+        ["text", 4096, 0]
+    ]) {
+        const length = Array.from(message[key]).length;
+        if (length < min || length > max)
+            throw new Error(`invalid notification ${key}`);
+    }
+    const timestamp = message.occurredAt;
+    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(timestamp) ||
+        !Number.isFinite(Date.parse(timestamp))) {
+        throw new Error("invalid notification occurredAt");
+    }
+}
+function object(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("invalid task notification object");
+    return value;
+}
+function knownFields(value, required, optional = []) {
+    if (required.some((key) => !(key in value)) ||
+        Object.keys(value).some((key) => !required.includes(key) && !optional.includes(key)))
+        throw new Error("invalid task notification fields");
+}
+function eventType(value) {
+    return Number.isInteger(value) && Number(value) >= 101 && Number(value) <= 115;
+}
+function sequence(value) {
+    return Number.isSafeInteger(value) && Number(value) > 0;
+}
+function validateTaskNotification(message) {
+    const task = object(message.task), event = object(message.taskEvent);
+    knownFields(task, ["id", "title", "status", "row_version", "handler_epoch"], ["responsible_party", "current_handler"]);
+    knownFields(event, ["id", "sequence", "evt_type", "actor", "summary", "payload"], ["task_conversation_id", "source_run_id"]);
+    if (task.id !== message.sourceId ||
+        typeof task.title !== "string" ||
+        !["backlog", "todo", "in_progress", "done", "cancelled"].includes(String(task.status)) ||
+        !sequence(task.row_version) ||
+        !sequence(task.handler_epoch))
+        throw new Error("invalid task snapshot");
+    const actor = object(event.actor);
+    if (typeof actor.type !== "string" ||
+        typeof actor.id !== "string" ||
+        typeof event.summary !== "string")
+        throw new Error("invalid event actor or summary");
+    object(event.payload);
+    if (!eventType(message.evt_type) ||
+        message.evt_type !== event.evt_type ||
+        event.id !== message.eventId ||
+        !sequence(event.sequence) ||
+        message.timelineThroughSequence !== event.sequence)
+        throw new Error("invalid task event identity");
+    if (message.timelineTruncated !== undefined && typeof message.timelineTruncated !== "boolean")
+        throw new Error("invalid timeline truncation");
+    if (!Array.isArray(message.timeline) || message.timeline.length > 20)
+        throw new Error("invalid task timeline");
+    let previous = 0;
+    for (const value of message.timeline) {
+        const item = object(value);
+        knownFields(item, ["eventId", "sequence", "evt_type", "summary"]);
+        if (typeof item.eventId !== "string" ||
+            typeof item.summary !== "string" ||
+            !eventType(item.evt_type) ||
+            !sequence(item.sequence) ||
+            Number(item.sequence) <= previous ||
+            Number(item.sequence) > Number(event.sequence))
+            throw new Error("invalid task timeline order");
+        previous = Number(item.sequence);
+    }
+    checkScalars(message);
+}
+function checkScalars(value) {
+    if (typeof value === "string") {
+        for (const char of value) {
+            const code = char.codePointAt(0);
+            if (code >= 0xd800 && code <= 0xdfff)
+                throw new Error("notification contains an unpaired surrogate");
+        }
+    }
+    else if (Array.isArray(value))
+        value.forEach(checkScalars);
+    else if (value && typeof value === "object")
+        for (const [key, item] of Object.entries(value)) {
+            checkScalars(key);
+            checkScalars(item);
+        }
+}

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

@@ -0,0 +1,9 @@
+import type { AsyncUserInputQuestion, QuestionRequest, QuestionResponse } from "./generated/protocol-types.js";
+/** 校验公开问题快照；不裁剪选项或把损坏的表单降为普通文字。 */
+export declare function assertAsyncQuestions(value: unknown): asserts value is AsyncUserInputQuestion[];
+/** 异步表单由交互事件授权回答；消息快照本身不代表仍有活动轮次。 */
+export declare function assertQuestionRequest(value: unknown): asserts value is QuestionRequest;
+/** 只校验响应形状；题目归属、漏题和排序由持有原始表单的 Adapter 核对。 */
+export declare function assertQuestionResponse(value: unknown): asserts value is QuestionResponse;
+/** 两条补充路径使用同一原题关联；只校验并编码数据，不解析正文或执行模板。 */
+export declare function questionAnswerText(request: QuestionRequest, value: unknown): string;

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

@@ -0,0 +1,84 @@
+import { assertJsonValue } from "./context.js";
+const invalidResponse = () => Object.assign(new TypeError("INVALID_QUESTION_RESPONSE"), { code: "INVALID_QUESTION_RESPONSE" });
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const text = (value) => typeof value === "string" && value.trim().length > 0 && Array.from(value).length <= 4096;
+const fields = (value, allowed) => Object.keys(value).every((key) => allowed.includes(key));
+/** 校验公开问题快照；不裁剪选项或把损坏的表单降为普通文字。 */
+export function assertAsyncQuestions(value) {
+    assertJsonValue(value);
+    if (!Array.isArray(value) ||
+        value.length > 50 ||
+        value.some((question) => !record(question) ||
+            !fields(question, ["title", "options"]) ||
+            !text(question.title) ||
+            !(question.options === null ||
+                (Array.isArray(question.options) &&
+                    question.options.length <= 50 &&
+                    question.options.every(text)))))
+        throw new TypeError("INVALID_ASYNC_QUESTIONS");
+}
+/** 异步表单由交互事件授权回答；消息快照本身不代表仍有活动轮次。 */
+export function assertQuestionRequest(value) {
+    assertJsonValue(value);
+    if (!record(value) ||
+        !fields(value, ["schema", "messageId", "questions"]) ||
+        value.schema !== "octo.question-request/v1" ||
+        typeof value.messageId !== "string" ||
+        !value.messageId ||
+        !Array.isArray(value.questions) ||
+        !value.questions.length ||
+        value.questions.length > 50)
+        throw new TypeError("INVALID_QUESTION_REQUEST");
+    for (const [index, q] of value.questions.entries()) {
+        if (!record(q) ||
+            !fields(q, ["id", "title", "options", "allowCustom"]) ||
+            q.id !== `q:${index}` ||
+            q.allowCustom !== true)
+            throw new TypeError("INVALID_QUESTION_REQUEST");
+        assertAsyncQuestions([{ title: q.title, options: q.options }]);
+    }
+}
+/** 只校验响应形状；题目归属、漏题和排序由持有原始表单的 Adapter 核对。 */
+export function assertQuestionResponse(value) {
+    try {
+        assertJsonValue(value);
+    }
+    catch {
+        throw invalidResponse();
+    }
+    if (!record(value) ||
+        !fields(value, ["schema", "answers"]) ||
+        value.schema !== "octo.question-response/v1" ||
+        !Array.isArray(value.answers) ||
+        !value.answers.length ||
+        value.answers.length > 50)
+        throw invalidResponse();
+    const ids = new Set();
+    for (const answer of value.answers) {
+        if (!record(answer) ||
+            !fields(answer, ["questionId", "text"]) ||
+            typeof answer.questionId !== "string" ||
+            !/^q:(0|[1-9][0-9]?)$/.test(answer.questionId) ||
+            ids.has(answer.questionId) ||
+            !text(answer.text))
+            throw invalidResponse();
+        ids.add(answer.questionId);
+    }
+}
+/** 两条补充路径使用同一原题关联；只校验并编码数据，不解析正文或执行模板。 */
+export function questionAnswerText(request, value) {
+    assertQuestionRequest(request);
+    assertQuestionResponse(value);
+    if (value.answers.length !== request.questions.length ||
+        value.answers.some((answer) => !request.questions.some((q) => q.id === answer.questionId)))
+        throw invalidResponse();
+    return ("Answer to async user questions:\n" +
+        JSON.stringify({
+            messageId: request.messageId,
+            answers: request.questions.map((q) => ({
+                questionId: q.id,
+                title: q.title,
+                text: value.answers.find((a) => a.questionId === q.id).text
+            }))
+        }));
+}

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

@@ -0,0 +1,20 @@
+import { type CanonicalEvent } from "./index.js";
+import type { ProtocolMode, RunProtocolErrorCode, HostInvokeOptions, HostRunReceipt, HostFrame, NativeHostFrame, CanonicalHostFrame, ControlHostFrame, HostControl, NativeInteractionResponse, AdapterProtocolSupport } from "./generated/protocol-types.js";
+export type { ProtocolMode, RunProtocolErrorCode, HostInvokeOptions, HostRunReceipt, HostFrame, NativeHostFrame, CanonicalHostFrame, ControlHostFrame, HostControl, NativeInteractionResponse, AdapterProtocolSupport };
+export declare const RUN_PROTOCOL_ERRORS: readonly ["PROTOCOL_MODE_INVALID", "PROTOCOL_MODE_UNSUPPORTED", "EXECUTION_PROTOCOL_MISMATCH", "EXECUTION_IDENTITY_CONFLICT", "NATIVE_METHOD_UNSUPPORTED", "NATIVE_RESPONSE_INVALID", "INTERACTION_NOT_ACTIVE", "INVALID_QUESTION_RESPONSE", "ASYNC_ANSWER_REJECTED", "OPERATION_OUTCOME_UNKNOWN", "HOST_EXECUTION_FAILED", "HOST_ENDED_WITHOUT_TERMINAL", "PROVIDER_MESSAGE_TOO_LARGE", "HOST_FRAME_TOO_LARGE", "STREAM_QUEUE_ITEM_TOO_LARGE", "STREAM_QUEUE_BYTES_EXCEEDED", "STREAM_QUEUE_ITEMS_EXCEEDED", "STREAM_GAP", "STREAM_EXPIRED", "REMOTE_NATIVE_UNSUPPORTED", "HOST_FRAME_INVALID", "HOST_CONTROL_INVALID", "HOST_RECEIPT_INVALID", "PROTOCOL_SUPPORT_INVALID"];
+export declare function protocolError(code: (typeof RUN_PROTOCOL_ERRORS)[number], message?: string): Error & {
+    code: (typeof RUN_PROTOCOL_ERRORS)[number];
+};
+/** Only an omitted mode defaults. A present undefined, null or empty value is invalid. */
+export declare function resolveHostInvokeOptions(value?: unknown): Readonly<Required<Pick<HostInvokeOptions, "protocolMode">> & HostInvokeOptions>;
+export declare function assertAdapterProtocolSupport(value: unknown): asserts value is AdapterProtocolSupport;
+export declare function assertProtocolSupport(support: AdapterProtocolSupport, options: HostInvokeOptions): void;
+export declare function assertNativeInteractionResponse(value: unknown): asserts value is NativeInteractionResponse;
+export declare function assertHostRunReceipt(value: unknown): asserts value is HostRunReceipt;
+export declare function assertHostControl(value: unknown): asserts value is HostControl;
+export declare function assertHostFrame(value: unknown): asserts value is HostFrame;
+/** Subscription identity always comes from admission, never from omitted subscribe options. */
+export declare function assertHostFrameIdentity(frame: HostFrame, receipt: HostRunReceipt): void;
+export declare function isHostTerminal(frame: HostFrame): boolean;
+/** A typed view of the selected canonical stream, never a payload cast or format guess. */
+export declare function canonicalEvents(frames: AsyncIterable<HostFrame>): AsyncGenerator<CanonicalEvent>;

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

@@ -0,0 +1,294 @@
+import { assertJsonValue } from "./context.js";
+import { assertExecutionEvidence } from "./actmode.js";
+import { assertCanonicalEvent, assertFailureEnvelope } from "./index.js";
+import { safeCapacityEvidence, isCodexLocalFailure } from "./failure.js";
+import { isStreamCapacityReason } from "./stream-limits.js";
+export const RUN_PROTOCOL_ERRORS = [
+    "PROTOCOL_MODE_INVALID",
+    "PROTOCOL_MODE_UNSUPPORTED",
+    "EXECUTION_PROTOCOL_MISMATCH",
+    "EXECUTION_IDENTITY_CONFLICT",
+    "NATIVE_METHOD_UNSUPPORTED",
+    "NATIVE_RESPONSE_INVALID",
+    "INTERACTION_NOT_ACTIVE",
+    "INVALID_QUESTION_RESPONSE",
+    "ASYNC_ANSWER_REJECTED",
+    "OPERATION_OUTCOME_UNKNOWN",
+    "HOST_EXECUTION_FAILED",
+    "HOST_ENDED_WITHOUT_TERMINAL",
+    "PROVIDER_MESSAGE_TOO_LARGE",
+    "HOST_FRAME_TOO_LARGE",
+    "STREAM_QUEUE_ITEM_TOO_LARGE",
+    "STREAM_QUEUE_BYTES_EXCEEDED",
+    "STREAM_QUEUE_ITEMS_EXCEEDED",
+    "STREAM_GAP",
+    "STREAM_EXPIRED",
+    "REMOTE_NATIVE_UNSUPPORTED",
+    "HOST_FRAME_INVALID",
+    "HOST_CONTROL_INVALID",
+    "HOST_RECEIPT_INVALID",
+    "PROTOCOL_SUPPORT_INVALID"
+];
+export function protocolError(code, message = code) {
+    return Object.assign(new Error(message), { code });
+}
+/** Only an omitted mode defaults. A present undefined, null or empty value is invalid. */
+export function resolveHostInvokeOptions(value = {}) {
+    if (!isRecord(value) ||
+        Object.keys(value).some((key) => !["protocolMode", "protocol"].includes(key)))
+        throw protocolError("PROTOCOL_MODE_INVALID");
+    const mode = Object.hasOwn(value, "protocolMode") ? value.protocolMode : "native";
+    if (mode !== "native" && mode !== "canonical")
+        throw protocolError("PROTOCOL_MODE_INVALID");
+    if (Object.hasOwn(value, "protocol") && !nonemptyString(value.protocol, 128))
+        throw protocolError("EXECUTION_PROTOCOL_MISMATCH");
+    assertProtocolJson(value, "PROTOCOL_MODE_INVALID");
+    return Object.freeze({
+        protocolMode: mode,
+        ...(typeof value.protocol === "string" ? { protocol: value.protocol } : {})
+    });
+}
+export function assertAdapterProtocolSupport(value) {
+    assertProtocolJson(value, "PROTOCOL_SUPPORT_INVALID");
+    if (!isRecord(value) ||
+        !exactKeys(value, ["protocol", "modes", "nativeMethods"]) ||
+        !nonemptyString(value.protocol, 128) ||
+        !Array.isArray(value.modes) ||
+        !value.modes.length ||
+        new Set(value.modes).size !== value.modes.length ||
+        value.modes.some((mode) => mode !== "native" && mode !== "canonical") ||
+        !Array.isArray(value.nativeMethods) ||
+        new Set(value.nativeMethods).size !== value.nativeMethods.length ||
+        value.nativeMethods.some((method) => !nonemptyString(method, 256)))
+        throw protocolError("PROTOCOL_SUPPORT_INVALID");
+    if (!value.modes.includes("native") && value.nativeMethods.length)
+        throw protocolError("PROTOCOL_SUPPORT_INVALID");
+}
+export function assertProtocolSupport(support, options) {
+    assertAdapterProtocolSupport(support);
+    const resolved = resolveHostInvokeOptions(options);
+    if (!support.modes.includes(resolved.protocolMode))
+        throw protocolError("PROTOCOL_MODE_UNSUPPORTED");
+    if (resolved.protocol !== undefined && resolved.protocol !== support.protocol)
+        throw protocolError("EXECUTION_PROTOCOL_MISMATCH");
+}
+export function assertNativeInteractionResponse(value) {
+    assertProtocolJson(value, "NATIVE_RESPONSE_INVALID");
+    if (!isRecord(value) ||
+        Object.keys(value).some((key) => !["requestId", "payload"].includes(key)) ||
+        !requestId(value.requestId) ||
+        !isRecord(value.payload))
+        throw protocolError("NATIVE_RESPONSE_INVALID");
+}
+const IDENTITY_KEYS = [
+    "run_id",
+    "invocation_id",
+    "stream_id",
+    "agent_session_id",
+    "session_generation",
+    "protocol_mode",
+    "protocol"
+];
+export function assertHostRunReceipt(value) {
+    assertProtocolJson(value, "HOST_RECEIPT_INVALID");
+    if (!isRecord(value) || !exactKeys(value, IDENTITY_KEYS) || !validIdentity(value))
+        throw protocolError("HOST_RECEIPT_INVALID");
+}
+export function assertHostControl(value) {
+    assertProtocolJson(value, "HOST_CONTROL_INVALID");
+    if (!isRecord(value))
+        throw protocolError("HOST_CONTROL_INVALID");
+    if (value.type === "evidence" &&
+        value.name === "execution" &&
+        exactKeys(value, ["type", "name", "payload"])) {
+        try {
+            assertExecutionEvidence(value.payload);
+        }
+        catch {
+            throw protocolError("HOST_CONTROL_INVALID");
+        }
+        return;
+    }
+    if (value.type === "evidence" &&
+        exactKeys(value, ["type", "name", "payload"]) &&
+        value.name === "session" &&
+        isRecord(value.payload)) {
+        return;
+    }
+    if (value.type === "state" &&
+        exactKeys(value, ["type", "state"]) &&
+        ["running", "completed", "failed", "cancelled", "lost"].includes(String(value.state)))
+        return;
+    if (value.type === "error" &&
+        exactKeys(value, ["type", "code", "message"], ["failure"]) &&
+        RUN_PROTOCOL_ERRORS.some((code) => code === value.code) &&
+        typeof value.message === "string") {
+        if (Object.hasOwn(value, "failure")) {
+            try {
+                assertFailureEnvelope(value.failure);
+                const evidence = safeCapacityEvidence(value.failure.params);
+                const localCodex = value.code === "HOST_EXECUTION_FAILED" && isCodexLocalFailure(value.failure);
+                if ((!localCodex &&
+                    (!isStreamCapacityReason(value.code) || value.failure.reasonCode !== value.code)) ||
+                    !exactKeys(value.failure, [
+                        "schemaVersion",
+                        "code",
+                        "reasonCode",
+                        "category",
+                        "stage",
+                        "messageKey",
+                        "params",
+                        "retryable",
+                        "action",
+                        "diagnosticId",
+                        "source",
+                        "occurredAt"
+                    ], ["retryAfterMs", "cause"]) ||
+                    !exactKeys(value.failure.source, ["component"], ["adapter"]) ||
+                    !exactKeys(value.failure.action, ["type", "labelKey"]) ||
+                    (value.failure.cause !== undefined &&
+                        !exactKeys(value.failure.cause, ["reasonCode"], ["httpStatus"])) ||
+                    Object.entries(value.failure.params).some(([key, entry]) => evidence[key] !== entry))
+                    throw protocolError("HOST_CONTROL_INVALID");
+            }
+            catch {
+                throw protocolError("HOST_CONTROL_INVALID");
+            }
+        }
+        return;
+    }
+    if (value.type === "interaction" &&
+        exactKeys(value, ["type", "requestId", "status"], ["expiresAt", "responseRequired"]) &&
+        requestId(value.requestId) &&
+        ["pending", "resolved", "expired", "invalidated"].includes(String(value.status)) &&
+        (!Object.hasOwn(value, "expiresAt") || safeInteger(value.expiresAt, 1)) &&
+        (value.status !== "pending" || safeInteger(value.expiresAt, 1)) &&
+        (!Object.hasOwn(value, "responseRequired") ||
+            (value.status === "pending" && typeof value.responseRequired === "boolean")))
+        return;
+    if (value.type === "gap" &&
+        exactKeys(value, ["type", "requested_after_seq", "oldest_seq", "latest_seq"]) &&
+        safeInteger(value.requested_after_seq, 0) &&
+        safeInteger(value.oldest_seq, 1) &&
+        safeInteger(value.latest_seq, 0) &&
+        value.requested_after_seq + 1 < value.oldest_seq &&
+        value.oldest_seq <= value.latest_seq + 1)
+        return;
+    throw protocolError("HOST_CONTROL_INVALID");
+}
+export function assertHostFrame(value) {
+    assertProtocolJson(value, "HOST_FRAME_INVALID");
+    if (!isRecord(value) || !validIdentity(value) || !safeInteger(value.seq, 1))
+        throw protocolError("HOST_FRAME_INVALID");
+    const identity = [...IDENTITY_KEYS, "seq", "kind"];
+    if (value.kind === "native" &&
+        value.protocol_mode === "native" &&
+        exactKeys(value, [...identity, "messageKind", "payload"]) &&
+        ["response", "notification", "request", "message"].includes(String(value.messageKind)) &&
+        isRecord(value.payload))
+        return;
+    if (value.kind === "canonical" &&
+        value.protocol_mode === "canonical" &&
+        exactKeys(value, [...identity, "event"])) {
+        if (!isRecord(value.event) || !exactKeys(value.event, ["protocolVersion", "type", "payload"]))
+            throw protocolError("HOST_FRAME_INVALID");
+        try {
+            assertCanonicalEvent(value.event);
+        }
+        catch {
+            throw protocolError("HOST_FRAME_INVALID");
+        }
+        for (const key of ["messageId", "stepId", "role", "status", "text", "reason", "message"]) {
+            if (Object.hasOwn(value.event.payload, key) &&
+                typeof Reflect.get(value.event.payload, key) !== "string")
+                throw protocolError("HOST_FRAME_INVALID", `CanonicalEvent.payload.${key} must be a string`);
+        }
+        return;
+    }
+    if (value.kind === "control" && exactKeys(value, [...identity, "control"])) {
+        assertHostControl(value.control);
+        return;
+    }
+    throw protocolError("HOST_FRAME_INVALID");
+}
+/** Subscription identity always comes from admission, never from omitted subscribe options. */
+export function assertHostFrameIdentity(frame, receipt) {
+    assertHostFrame(frame);
+    assertHostRunReceipt(receipt);
+    if (IDENTITY_KEYS.some((key) => Reflect.get(frame, key) !== Reflect.get(receipt, key)))
+        throw protocolError("EXECUTION_IDENTITY_CONFLICT");
+}
+export function isHostTerminal(frame) {
+    return (frame.kind === "control" &&
+        frame.control.type === "state" &&
+        ["completed", "failed", "cancelled", "lost"].includes(frame.control.state));
+}
+/** A typed view of the selected canonical stream, never a payload cast or format guess. */
+export async function* canonicalEvents(frames) {
+    let identity;
+    let lastSeq;
+    for await (const frame of frames) {
+        assertHostFrame(frame);
+        if (frame.protocol_mode !== "canonical")
+            throw protocolError("EXECUTION_PROTOCOL_MISMATCH");
+        identity ??= {
+            run_id: frame.run_id,
+            invocation_id: frame.invocation_id,
+            stream_id: frame.stream_id,
+            agent_session_id: frame.agent_session_id,
+            session_generation: frame.session_generation,
+            protocol_mode: frame.protocol_mode,
+            protocol: frame.protocol
+        };
+        assertHostFrameIdentity(frame, identity);
+        if (lastSeq !== undefined && frame.seq !== lastSeq + 1)
+            throw protocolError("STREAM_GAP");
+        lastSeq = frame.seq;
+        if (frame.kind === "canonical") {
+            assertCanonicalEvent(frame.event);
+            yield frame.event;
+        }
+        else if (frame.kind === "control" && frame.control.type === "gap")
+            throw protocolError("STREAM_GAP");
+        else if (frame.kind === "control" && frame.control.type === "error")
+            throw Object.assign(new Error(frame.control.message), {
+                code: frame.control.code,
+                ...(frame.control.failure
+                    ? {
+                        ...safeCapacityEvidence(frame.control.failure.params),
+                        failure: frame.control.failure
+                    }
+                    : {})
+            });
+    }
+}
+function validIdentity(value) {
+    return (["run_id", "invocation_id", "stream_id", "agent_session_id"].every((key) => nonemptyString(value[key], 256)) &&
+        safeInteger(value.session_generation, 0) &&
+        nonemptyString(value.protocol, 128) &&
+        (value.protocol_mode === "native" || value.protocol_mode === "canonical"));
+}
+function assertProtocolJson(value, code) {
+    try {
+        assertJsonValue(value);
+    }
+    catch {
+        throw protocolError(code);
+    }
+}
+function nonemptyString(value, max) {
+    return typeof value === "string" && value.length > 0 && Array.from(value).length <= max;
+}
+function safeInteger(value, min) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= min;
+}
+function requestId(value) {
+    return nonemptyString(value, 256) || (typeof value === "number" && Number.isSafeInteger(value));
+}
+function exactKeys(value, required, optional = []) {
+    return (required.every((key) => Object.hasOwn(value, key)) &&
+        Object.keys(value).every((key) => required.includes(key) || optional.includes(key)));
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

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

@@ -0,0 +1,3 @@
+import type { ResolvedRuntimeSelection } from "./generated/protocol-types.js";
+export declare const RUNTIME_SELECTION_SCHEMA: "octo.runtime-selection/v2";
+export declare function assertResolvedRuntimeSelection(value: unknown): asserts value is ResolvedRuntimeSelection;

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

@@ -0,0 +1,68 @@
+import { assertJsonValue } from "./context.js";
+export const RUNTIME_SELECTION_SCHEMA = "octo.runtime-selection/v2";
+export function assertResolvedRuntimeSelection(value) {
+    object(value, "RESOLVED_RUNTIME_SELECTION_REQUIRED");
+    assertJsonValue(value);
+    fields(value, [
+        "schema",
+        "selection_mode",
+        "explicit_runtime_id",
+        "authorized_candidates",
+        "offline_behavior",
+        "failover"
+    ]);
+    if (value.schema !== RUNTIME_SELECTION_SCHEMA ||
+        !["explicit", "candidates"].includes(value.selection_mode) ||
+        !["wait", "fail"].includes(value.offline_behavior) ||
+        !["candidates", "none"].includes(value.failover))
+        invalid();
+    if (value.selection_mode === "explicit")
+        text(value.explicit_runtime_id);
+    else if (Object.hasOwn(value, "explicit_runtime_id"))
+        invalid();
+    if (value.selection_mode === "explicit" && value.failover !== "none")
+        invalid();
+    if (!Array.isArray(value.authorized_candidates) ||
+        value.authorized_candidates.length === 0 ||
+        value.authorized_candidates.length > 64)
+        invalid();
+    const runtimeIds = new Set();
+    const priorities = new Set();
+    for (const candidate of value.authorized_candidates) {
+        object(candidate);
+        fields(candidate, ["runtime_id", "priority", "owner_subject_type", "owner_subject_id"]);
+        text(candidate.runtime_id);
+        text(candidate.owner_subject_type);
+        if (candidate.owner_subject_type !== "user" && candidate.owner_subject_type !== "teamspace")
+            invalid();
+        text(candidate.owner_subject_id);
+        positiveInteger(candidate.priority);
+        if (runtimeIds.has(candidate.runtime_id) || priorities.has(candidate.priority))
+            invalid();
+        runtimeIds.add(candidate.runtime_id);
+        priorities.add(candidate.priority);
+    }
+    if (value.selection_mode === "explicit" &&
+        (value.authorized_candidates.length !== 1 ||
+            !runtimeIds.has(value.explicit_runtime_id)))
+        invalid();
+}
+function invalid() {
+    throw new TypeError("RESOLVED_RUNTIME_SELECTION_INVALID");
+}
+function object(value, code = "RESOLVED_RUNTIME_SELECTION_INVALID") {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new TypeError(code);
+}
+function fields(value, allowed) {
+    if (Object.keys(value).some((key) => !allowed.includes(key)))
+        invalid();
+}
+function text(value) {
+    if (typeof value !== "string" || value.length === 0 || [...value].length > 191)
+        invalid();
+}
+function positiveInteger(value) {
+    if (!Number.isSafeInteger(value) || value < 1)
+        invalid();
+}

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

@@ -0,0 +1,5 @@
+import type { KernelStatus, ServiceProcessSnapshot } from "./generated/protocol-types.js";
+/** status 的安全进程白名单与共享 Schema 对齐，拒绝任意 argv/env 扩展字段。 */
+export declare function assertServiceProcessSnapshot(value: unknown): asserts value is ServiceProcessSnapshot;
+/** 兼容没有服务快照的旧 status；有快照时完整校验后才能交给 doctor。 */
+export declare function assertKernelStatus(value: unknown): asserts value is KernelStatus;