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

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

@@ -0,0 +1,80 @@
+import { assertContextEnvelope, assertContextEnvs, assertResolvedExecutionPlan } from "./context.js";
+function executionValues(context) {
+    const result = {};
+    for (const item of [...context.items].sort((a, b) => `${a.namespace}/${a.name}` < `${b.namespace}/${b.name}`
+        ? -1
+        : `${a.namespace}/${a.name}` > `${b.namespace}/${b.name}`
+            ? 1
+            : 0)) {
+        if (item.namespace === "octo.execution" &&
+            ["adapter", "workspace", "limits", "envs", "mcp", "actmode"].includes(item.name))
+            result[item.name] = item.payload;
+        if (item.namespace === "octo.security" && item.name === "approval_policy")
+            result.approval_policy = item.payload;
+        if (item.namespace === "octo.runtime" && item.name === "selection")
+            result.runtime = item.payload;
+        if (item.namespace === "octo.execution" && item.name === "model") {
+            if (isObject(item.payload.selection))
+                result.model = item.payload.selection;
+            if (isObject(item.payload.reasoning))
+                result.reasoning = item.payload.reasoning;
+        }
+    }
+    return result;
+}
+/** 验证有效 Context 与冻结执行计划逐项一致；不匹配时禁止进入资源准备。 */
+export function assertFrozenContextPlan(context, plan) {
+    assertContextEnvelope(context);
+    assertResolvedExecutionPlan(plan);
+    const execution = executionValues(context);
+    const match = (field, property, actual) => {
+        if (execution[field]?.[property] !== actual)
+            throw new TypeError("CONTEXT_PLAN_MISMATCH");
+    };
+    match("adapter", "type", plan.adapter_type);
+    match("adapter", "provider_agent_id", plan.provider_agent_id);
+    const workspace = execution.workspace;
+    if (!workspace)
+        throw new TypeError("CONTEXT_PLAN_MISMATCH");
+    if (workspace.mode === "fixed") {
+        match("workspace", "path", plan.workdir);
+        if (plan.workspace &&
+            (plan.workspace.mode !== "fixed" || plan.workspace.path !== workspace.path))
+            throw new TypeError("CONTEXT_PLAN_MISMATCH");
+    }
+    if (workspace.mode === "random" && (plan.workdir !== "" || plan.workspace?.mode !== "random"))
+        throw new TypeError("CONTEXT_PLAN_MISMATCH");
+    if (workspace.mode === "none" &&
+        (plan.agent_source !== "preset" || plan.workdir || plan.workspace?.mode !== "none"))
+        throw new TypeError("CONTEXT_PLAN_MISMATCH");
+    match("approval_policy", "mode", plan.approval_mode);
+    match("model", "id", plan.model);
+    match("reasoning", "effort", plan.effort);
+    match("actmode", "mode", plan.actmode);
+    const canonical = (value) => JSON.stringify(value, function (_key, child) {
+        return isObject(child)
+            ? Object.fromEntries(Object.keys(child)
+                .sort()
+                .map((key) => [key, child[key]]))
+            : child;
+    });
+    if (canonical(execution.mcp ?? { mcpServers: {} }) !== canonical(plan.mcp ?? { mcpServers: {} }))
+        throw new TypeError("CONTEXT_PLAN_MISMATCH");
+    const envs = execution.envs ?? { env_variables: [] };
+    assertContextEnvs(envs);
+    const plannedEnvs = new Map((plan.envs?.env_variables ?? []).map((entry) => [entry.key, entry.value]));
+    if (envs.env_variables.length !== plannedEnvs.size ||
+        envs.env_variables.some((entry) => plannedEnvs.get(entry.key) !== entry.value))
+        throw new TypeError("CONTEXT_PLAN_MISMATCH");
+    const limits = execution.limits ?? {};
+    for (const property of new Set([
+        ...Object.keys(limits),
+        ...Object.keys(plan.runtime_limits ?? {})
+    ])) {
+        if (limits[property] !== plan.runtime_limits?.[property])
+            throw new TypeError("CONTEXT_PLAN_MISMATCH");
+    }
+}
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

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

@@ -0,0 +1,4 @@
+type Payload = Record<string, unknown>;
+export declare const PROVIDER_DIAGNOSTIC_MAX_BYTES = 2048;
+export declare function assertExperiencePayload(type: string, payload: Payload): void;
+export {};

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

@@ -0,0 +1,166 @@
+export const PROVIDER_DIAGNOSTIC_MAX_BYTES = 2048;
+const kinds = new Set([
+    "starting",
+    "thinking",
+    "executing_tool",
+    "responding",
+    "waiting_approval",
+    "waiting_input",
+    "compacting",
+    "retrying",
+    "working"
+]);
+const terminal = new Set(["completed", "failed", "cancelled"]);
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function string(value) {
+    if (typeof value !== "string" || value.length === 0 || Array.from(value).length > 191)
+        throw new TypeError("experience identifier must contain 1..191 characters");
+}
+function integer(value, minimum = 0) {
+    if (!Number.isSafeInteger(value) || Number(value) < minimum)
+        throw new TypeError("experience count must be a safe non-negative integer");
+}
+function fields(payload, allowed, required) {
+    if (Object.keys(payload).some((key) => !allowed.includes(key)) ||
+        required.some((key) => !(key in payload)))
+        throw new TypeError("experience payload contains unknown or missing fields");
+}
+function info(value) {
+    if (!record(value))
+        throw new TypeError("activity info must be an object");
+    fields(value, ["messageKey", "params", "attempt", "retryAfterMs"], []);
+    if (value.messageKey !== undefined)
+        string(value.messageKey);
+    if (value.params !== undefined &&
+        (!record(value.params) ||
+            Object.values(value.params).some((item) => !["string", "number", "boolean"].includes(typeof item))))
+        throw new TypeError("activity params must contain scalar values");
+    if (value.attempt !== undefined)
+        integer(value.attempt, 1);
+    if (value.retryAfterMs !== undefined)
+        integer(value.retryAfterMs);
+}
+export function assertExperiencePayload(type, payload) {
+    switch (type) {
+        case "activity.started": {
+            fields(payload, ["activityId", "kind", "subject", "source", "info", "startedAtMs"], ["activityId", "kind", "subject", "source", "info"]);
+            string(payload.activityId);
+            if (!kinds.has(String(payload.kind)) ||
+                !["provider", "harness"].includes(String(payload.source)))
+                throw new TypeError("invalid activity kind or source");
+            if (!record(payload.subject) ||
+                !["run", "message", "tool", "interaction"].includes(String(payload.subject.type)))
+                throw new TypeError("invalid activity subject");
+            fields(payload.subject, ["type", "id"], payload.subject.type === "run" ? ["type"] : ["type", "id"]);
+            if (payload.subject.type === "run" && payload.subject.id !== undefined)
+                throw new TypeError("run subject cannot contain id");
+            if (payload.subject.type !== "run")
+                string(payload.subject.id);
+            info(payload.info);
+            if (payload.startedAtMs !== undefined)
+                integer(payload.startedAtMs);
+            break;
+        }
+        case "activity.updated":
+            fields(payload, ["activityId", "info"], ["activityId", "info"]);
+            string(payload.activityId);
+            info(payload.info);
+            break;
+        case "activity.finished":
+            fields(payload, ["activityId", "status", "endedAtMs"], ["activityId", "status"]);
+            string(payload.activityId);
+            if (!terminal.has(String(payload.status)) && payload.status !== "superseded")
+                throw new TypeError("invalid activity terminal");
+            if (payload.endedAtMs !== undefined)
+                integer(payload.endedAtMs);
+            break;
+        case "plan.updated":
+            fields(payload, ["planId", "revision", "explanation", "steps"], ["planId", "revision", "explanation", "steps"]);
+            string(payload.planId);
+            integer(payload.revision, 1);
+            if (payload.explanation !== null &&
+                (typeof payload.explanation !== "string" || payload.explanation.length > 4096))
+                throw new TypeError("invalid plan explanation");
+            if (!Array.isArray(payload.steps) || payload.steps.length > 200)
+                throw new TypeError("invalid plan steps");
+            for (const step of payload.steps) {
+                if (!record(step))
+                    throw new TypeError("invalid plan step");
+                fields(step, ["text", "status"], ["text", "status"]);
+                if (typeof step.text !== "string" ||
+                    !step.text ||
+                    step.text.length > 4096 ||
+                    !["pending", "in_progress", "completed", "blocked", "cancelled"].includes(String(step.status)))
+                    throw new TypeError("invalid plan step");
+            }
+            break;
+        case "tool_call.progress": {
+            fields(payload, ["id", "progress"], ["id", "progress"]);
+            string(payload.id);
+            if (!record(payload.progress))
+                throw new TypeError("invalid tool progress");
+            const progress = payload.progress;
+            fields(progress, ["message", "completed", "total", "unit"], []);
+            if (progress.message !== undefined &&
+                (typeof progress.message !== "string" || progress.message.length > 4096))
+                throw new TypeError("invalid progress message");
+            if (["completed", "total", "unit"].some((key) => key in progress)) {
+                integer(progress.completed);
+                integer(progress.total, 1);
+                if (progress.completed > progress.total ||
+                    !["items", "bytes", "steps"].includes(String(progress.unit)))
+                    throw new TypeError("invalid progress quantity");
+            }
+            break;
+        }
+        case "run.notice": {
+            fields(payload, ["noticeId", "code", "severity", "params", "relatedActivityId", "relatedItemId"], ["noticeId", "code", "severity", "params"]);
+            string(payload.noticeId);
+            if (!["info", "warning"].includes(String(payload.severity)) || !record(payload.params))
+                throw new TypeError("invalid notice");
+            const params = payload.params;
+            switch (payload.code) {
+                case "context_compacted":
+                    fields(params, [], []);
+                    break;
+                case "retry_scheduled":
+                    fields(params, ["attempt", "retryAfterMs"], ["attempt"]);
+                    integer(params.attempt, 1);
+                    if (params.retryAfterMs !== undefined)
+                        integer(params.retryAfterMs);
+                    break;
+                case "model_rerouted":
+                    fields(params, ["fromModel", "toModel", "reasonCode"], ["fromModel", "toModel"]);
+                    string(params.fromModel);
+                    string(params.toModel);
+                    if (params.reasonCode !== undefined)
+                        string(params.reasonCode);
+                    break;
+                case "config_warning":
+                    fields(params, ["warningCode"], ["warningCode"]);
+                    string(params.warningCode);
+                    break;
+                case "provider_diagnostic":
+                    fields(params, ["adapter", "diagnosticId", "category", "message"], ["adapter", "diagnosticId", "category", "message"]);
+                    string(params.adapter);
+                    string(params.diagnosticId);
+                    string(params.category);
+                    if (payload.severity !== "warning" ||
+                        typeof params.message !== "string" ||
+                        !params.message.trim() ||
+                        new TextEncoder().encode(params.message).byteLength > PROVIDER_DIAGNOSTIC_MAX_BYTES)
+                        throw new TypeError("invalid provider diagnostic");
+                    break;
+                default:
+                    throw new TypeError("invalid notice code");
+            }
+            if (payload.relatedActivityId !== undefined)
+                string(payload.relatedActivityId);
+            if (payload.relatedItemId !== undefined)
+                string(payload.relatedItemId);
+            break;
+        }
+    }
+}

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

@@ -0,0 +1,69 @@
+import type { FailureAction, FailureEnvelope, FailureSource } from "./generated/protocol-types.js";
+export type FailureDomain = "runtime" | "adapter" | "provider" | "system";
+export interface FailureClassificationContext {
+    stage: string;
+    source?: FailureSource;
+    defaultDomain: FailureDomain;
+    /** Agent Work Run identity; standard arun IDs deterministically own the diagnostic UUID. */
+    runId?: string;
+    diagnosticId?: string;
+    occurredAt?: string;
+    /** Only trusted downstream boundaries may retain a previously validated envelope. */
+    preserveExisting?: boolean;
+}
+interface CatalogEntry {
+    category: string;
+    message: string;
+    messageKey: string;
+    retryable: boolean;
+    retryAfterMs?: number;
+    action: FailureAction;
+}
+/** Runtime-owned subset of the global catalog in improvement 70-01. */
+export declare const FAILURE_CATALOG: Readonly<{
+    "OH-INP-5001": CatalogEntry;
+    "OH-INP-5002": CatalogEntry;
+    "OH-INP-5003": CatalogEntry;
+    "OH-INP-5004": CatalogEntry;
+    "OH-INP-5005": CatalogEntry;
+    "OH-RUN-2002": CatalogEntry;
+    "OH-RUN-2003": CatalogEntry;
+    "OH-RUN-2004": CatalogEntry;
+    "OH-RUN-2005": CatalogEntry;
+    "OH-RUN-2008": CatalogEntry;
+    "OH-ADP-3002": CatalogEntry;
+    "OH-ADP-3003": CatalogEntry;
+    "OH-ADP-3004": CatalogEntry;
+    "OH-ADP-3005": CatalogEntry;
+    "OH-ADP-3006": CatalogEntry;
+    "OH-ADP-3007": CatalogEntry;
+    "OH-ADP-3008": CatalogEntry;
+    "OH-ADP-3009": CatalogEntry;
+    "OH-ADP-3010": CatalogEntry;
+    "OH-ADP-3011": CatalogEntry;
+    "OH-ADP-3012": CatalogEntry;
+    "OH-ADP-3013": CatalogEntry;
+    "OH-PRV-4001": CatalogEntry;
+    "OH-PRV-4002": CatalogEntry;
+    "OH-PRV-4003": CatalogEntry;
+    "OH-PRV-4004": CatalogEntry;
+    "OH-PRV-4005": CatalogEntry;
+    "OH-PRV-4006": CatalogEntry;
+    "OH-PRV-4007": CatalogEntry;
+    "OH-PRV-4008": CatalogEntry;
+    "OH-PRV-4099": CatalogEntry;
+    "OH-SYS-9001": CatalogEntry;
+}>;
+export type PublicFailureCode = keyof typeof FAILURE_CATALOG;
+/** Classify untrusted adapter/provider error data without copying raw messages or secrets into the result. */
+export declare function classifyFailure(input: unknown, context: FailureClassificationContext): FailureEnvelope;
+/**
+ * Produce the backwards-compatible terminal payload (`code`/`message`) plus
+ * the structured envelope. Only allowlisted metadata survives this boundary.
+ */
+export declare function failurePayload(input: unknown, context: FailureClassificationContext): Record<string, unknown> & {
+    failure: FailureEnvelope;
+};
+export declare function failureMessage(code: string): string;
+export declare function isFailureEnvelope(value: unknown): value is FailureEnvelope;
+export {};