chainlesschain 0.166.68 → 0.166.70

package/src/lib/decision-layer/runtime.js

@@ -0,0 +1,238 @@
+import { randomUUID } from "node:crypto";
+
+import { runMeteredDirectModelCall } from "../direct-model-usage.js";
+import { isTerminalModelFailure } from "../model-failure-policy.js";
+import { markRuntimeLedgerPersistenceError } from "../runtime-usage-ledger.js";
+import {
+  createSkillDecisionRequest,
+  decisionDigest,
+  normalizeDecisionMode,
+  normalizeSkillDecisionProviderResult,
+  resolveSkillDecision,
+  SKILL_DECISION_OBSERVATION_SCHEMA,
+} from "./contracts.js";
+import { captureDecisionProviderAuthority } from "./provider-authority.js";
+
+export const SKILL_DECISION_RUNTIME_SCHEMA =
+  "chainlesschain.skill-decision-runtime/v1";
+
+const RUNTIMES = new WeakSet();
+const DEFAULT_TIMEOUT_MS = 800;
+
+function requiredText(value, label, maximum = 256) {
+  if (
+    typeof value !== "string" ||
+    value.trim() === "" ||
+    value.length > maximum ||
+    /\p{Cc}/u.test(value)
+  ) {
+    throw new TypeError(`${label} is required and bounded`);
+  }
+  return value.trim();
+}
+
+function timeoutSignal(signal, timeoutMs) {
+  const deadline = AbortSignal.timeout(timeoutMs);
+  return signal ? AbortSignal.any([signal, deadline]) : deadline;
+}
+
+function projectUnavailable(error) {
+  if (error?.name === "TimeoutError") return "provider-timeout";
+  if (error?.code === "CC_DECISION_PROVIDER_HTTP_ERROR") {
+    return "provider-http-error";
+  }
+  return "provider-unavailable";
+}
+
+function asPersistenceError(error) {
+  if (error?.runtimeLedgerPersistence === true) return error;
+  try {
+    return markRuntimeLedgerPersistenceError(error);
+  } catch {
+    return markRuntimeLedgerPersistenceError(
+      new Error("decision observation persistence failed", { cause: error }),
+    );
+  }
+}
+
+export function createSkillDecisionRuntime({
+  mode = "off",
+  tenantId = null,
+  sessionId = null,
+  provider = null,
+  persist = null,
+  observe = null,
+  sessionBudget = null,
+  thresholds = {},
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  idGenerator = () => randomUUID(),
+  now = () => new Date(),
+} = {}) {
+  const normalizedMode = normalizeDecisionMode(mode);
+  if (
+    !Number.isSafeInteger(timeoutMs) ||
+    timeoutMs < 50 ||
+    timeoutMs > 30_000
+  ) {
+    throw new TypeError(
+      "decision timeout must be an integer from 50 to 30000 ms",
+    );
+  }
+  if (typeof idGenerator !== "function" || typeof now !== "function") {
+    throw new TypeError("decision runtime generators must be functions");
+  }
+  let providerAuthority = null;
+  let boundTenantId = null;
+  let boundSessionId = null;
+  if (normalizedMode !== "off") {
+    providerAuthority = captureDecisionProviderAuthority(provider);
+    boundTenantId = requiredText(tenantId, "tenantId");
+    boundSessionId = requiredText(sessionId, "sessionId");
+    if (typeof persist !== "function" || typeof observe !== "function") {
+      throw new TypeError(
+        "enabled decision runtime requires usage and observation persistence",
+      );
+    }
+  }
+
+  const writeObservation = async (observation) => {
+    if (normalizedMode === "off") return;
+    try {
+      await observe(observation);
+    } catch (error) {
+      throw asPersistenceError(error);
+    }
+  };
+
+  const runtime = Object.freeze({
+    schema: SKILL_DECISION_RUNTIME_SCHEMA,
+    mode: normalizedMode,
+    tenantId: boundTenantId,
+    sessionId: boundSessionId,
+    suggest: async ({
+      query,
+      candidates,
+      turnId,
+      contextRevision,
+      signal,
+    } = {}) => {
+      if (normalizedMode === "off") {
+        return Object.freeze({
+          schema: SKILL_DECISION_OBSERVATION_SCHEMA,
+          mode: normalizedMode,
+          status: "disabled",
+          visible: false,
+        });
+      }
+      if (signal?.aborted) throw signal.reason;
+      const decisionId = `skill-${requiredText(idGenerator(), "decisionId")}`;
+      const request = createSkillDecisionRequest({
+        decisionId,
+        tenantId: boundTenantId,
+        sessionId: boundSessionId,
+        turnId,
+        query,
+        candidates,
+        contextRevision,
+      });
+      const startedAt = now();
+      if (
+        !(startedAt instanceof Date) ||
+        !Number.isFinite(startedAt.getTime())
+      ) {
+        throw new TypeError("decision runtime clock returned an invalid date");
+      }
+      let outcome;
+      try {
+        const raw = await runMeteredDirectModelCall({
+          sessionId: boundSessionId,
+          persist,
+          provider: providerAuthority.provider,
+          model: providerAuthority.model,
+          source: "model",
+          operationId: `decision:${decisionId}`,
+          sessionBudget,
+          call: () =>
+            providerAuthority.decide(request, {
+              signal: timeoutSignal(signal, timeoutMs),
+            }),
+        });
+        const normalized = normalizeSkillDecisionProviderResult(request, raw);
+        const resolved = resolveSkillDecision(request, normalized, thresholds);
+        outcome = {
+          status: resolved.status,
+          reasonCode: resolved.reasonCode,
+          selectedCandidateId: resolved.selectedCandidateId,
+          selectedDigest: resolved.selectedDigest,
+          selectedSkillId: resolved.selectedSkillId,
+          needsSkillProbability: resolved.needsSkillProbability,
+          choiceConfidence: resolved.choiceConfidence,
+          resultDigest: resolved.resultDigest,
+        };
+      } catch (error) {
+        if (signal?.aborted || isTerminalModelFailure(error)) throw error;
+        outcome = {
+          status: "unavailable",
+          reasonCode: projectUnavailable(error),
+          selectedCandidateId: null,
+          selectedDigest: null,
+          selectedSkillId: null,
+          needsSkillProbability: null,
+          choiceConfidence: null,
+          resultDigest: null,
+        };
+      }
+      const finishedAt = now();
+      if (
+        !(finishedAt instanceof Date) ||
+        !Number.isFinite(finishedAt.getTime())
+      ) {
+        throw new TypeError("decision runtime clock returned an invalid date");
+      }
+      const observationCore = {
+        schema: SKILL_DECISION_OBSERVATION_SCHEMA,
+        decisionId,
+        mode: normalizedMode,
+        tenantId: boundTenantId,
+        sessionId: boundSessionId,
+        turnId: request.binding.turnId,
+        requestDigest: request.requestDigest,
+        candidateSetDigest: request.candidateSetDigest,
+        provider: providerAuthority.provider,
+        model: providerAuthority.model,
+        status: outcome.status,
+        reasonCode: outcome.reasonCode,
+        selectedDigest: outcome.selectedDigest,
+        resultDigest: outcome.resultDigest,
+        startedAt: startedAt.toISOString(),
+        finishedAt: finishedAt.toISOString(),
+        latencyMs: Math.max(0, finishedAt.getTime() - startedAt.getTime()),
+      };
+      const observation = Object.freeze({
+        ...observationCore,
+        observationDigest: decisionDigest(
+          SKILL_DECISION_OBSERVATION_SCHEMA,
+          observationCore,
+        ),
+      });
+      await writeObservation(observation);
+      return Object.freeze({
+        schema: SKILL_DECISION_OBSERVATION_SCHEMA,
+        decisionId,
+        mode: normalizedMode,
+        visible: normalizedMode === "suggest",
+        receiptRef: observation.observationDigest,
+        ...outcome,
+      });
+    },
+  });
+  RUNTIMES.add(runtime);
+  return runtime;
+}
+
+export function captureSkillDecisionRuntime(value) {
+  if (!RUNTIMES.has(value)) {
+    throw new TypeError("a branded Skill decision runtime is required");
+  }
+  return value;
+}

package/src/lib/decision-layer/typesafe-provider.js

@@ -0,0 +1,74 @@
+import { openDecisionProviderAuthority } from "./provider-authority.js";
+
+const DEFAULT_BASE_URL = "https://api.typesafe.ai";
+
+function endpointFor(baseUrl) {
+  const parsed = new URL(baseUrl || DEFAULT_BASE_URL);
+  if (
+    parsed.protocol !== "https:" &&
+    parsed.hostname !== "127.0.0.1" &&
+    parsed.hostname !== "localhost"
+  ) {
+    throw new TypeError("decision provider URL must use HTTPS or loopback");
+  }
+  parsed.pathname = `${parsed.pathname.replace(/\/$/u, "")}/v1/systemone`;
+  parsed.search = "";
+  parsed.hash = "";
+  return parsed.toString();
+}
+
+function boundedSecret(value) {
+  if (typeof value !== "string" || value.length < 1 || value.length > 8192) {
+    throw new TypeError("TypeSafe API key is required");
+  }
+  return value;
+}
+
+function providerError(status) {
+  const error = new Error(
+    `TypeSafe decision request failed with status ${status}`,
+  );
+  error.code = "CC_DECISION_PROVIDER_HTTP_ERROR";
+  error.status = status;
+  return error;
+}
+
+export function createTypeSafeDecisionProvider({
+  apiKey,
+  baseUrl = DEFAULT_BASE_URL,
+  model = "jev-latest",
+  fetchImpl = globalThis.fetch,
+} = {}) {
+  const secret = boundedSecret(apiKey);
+  if (typeof fetchImpl !== "function") {
+    throw new TypeError("decision provider fetch implementation is required");
+  }
+  const endpoint = endpointFor(baseUrl);
+  return openDecisionProviderAuthority({
+    provider: "typesafe",
+    model,
+    decide: async (request, { signal } = {}) => {
+      const response = await fetchImpl(endpoint, {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${secret}`,
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({
+          model,
+          state: request.payload.state,
+          questions: request.payload.questions,
+        }),
+        signal,
+      });
+      if (!response?.ok) throw providerError(response?.status ?? 0);
+      const body = await response.json();
+      return {
+        provider: "typesafe",
+        model: typeof body?.model === "string" ? body.model : model,
+        answers: body?.answers,
+        usage: body?.usage,
+      };
+    },
+  });
+}

package/src/lib/evolution/evolution-deployment-loader.js

@@ -281,6 +281,10 @@ async function loadBuiltInFactories(commandName) {
       browserQuarantineOperatorRevocation,
       browserQuarantineLockMaintenance,
       browserDownloadArtifactDisposal,
+      volcengineFunctionExecution,
+      volcengineFunctionProcessExecutor,
+      volcengineFunctionReplay,
+      volcengineFunctionRevocationStatusFloor,
       ledgerPorts,
       artifactPorts,
       ledgerBackend,
@@ -313,6 +317,10 @@ async function loadBuiltInFactories(commandName) {
       import("./browser-quarantine-operator-revocation-authority.js"),
       import("./browser-quarantine-lock-maintenance-authority.js"),
       import("./browser-download-artifact-disposal-authority.js"),
+      import("./volcengine-function-execution-authority.js"),
+      import("./volcengine-function-process-executor.js"),
+      import("./volcengine-function-replay-store.js"),
+      import("./volcengine-function-revocation-status-floor-store.js"),
       import("./evolution-ledger-ports.js"),
       import("./evolution-artifact-ports.js"),
       import("./evolution-ledger-file-backend.js"),
@@ -443,6 +451,22 @@ async function loadBuiltInFactories(commandName) {
         browserQuarantineLockMaintenance.createBrowserQuarantineLockMaintenanceAuthority,
       createBrowserDownloadArtifactDisposalAuthority:
         browserDownloadArtifactDisposal.createBrowserDownloadArtifactDisposalAuthority,
+      createVolcengineFunctionExecutionAuthority:
+        volcengineFunctionExecution.createVolcengineFunctionExecutionAuthority,
+      createVolcengineFunctionProcessExecutionAuthority:
+        volcengineFunctionExecution.createVolcengineFunctionProcessExecutionAuthority,
+      revokeVolcengineFunctionExecutionAuthority:
+        volcengineFunctionExecution.revokeVolcengineFunctionExecutionAuthority,
+      createVolcengineFunctionRevocationAuthority:
+        volcengineFunctionExecution.createVolcengineFunctionRevocationAuthority,
+      createVolcengineFunctionRevocationEvidenceResolver:
+        volcengineFunctionExecution.createVolcengineFunctionRevocationEvidenceResolver,
+      createVolcengineFunctionProcessExecutor:
+        volcengineFunctionProcessExecutor.createVolcengineFunctionProcessExecutor,
+      createVolcengineFunctionReplayStore:
+        volcengineFunctionReplay.createVolcengineFunctionReplayStore,
+      createVolcengineFunctionRevocationStatusFloorStore:
+        volcengineFunctionRevocationStatusFloor.createVolcengineFunctionRevocationStatusFloorStore,
       createEvolutionLedgerDurableArtifactResolver:
         ledgerPorts.createEvolutionLedgerDurableArtifactResolver,
       createEvolutionArtifactPorts: (options) =>
@@ -799,6 +823,12 @@ function bindFactoriesToModule(factories, moduleDigest) {
     "createBrowserQuarantineOperatorRevocationAuthority",
     "createBrowserQuarantineLockMaintenanceAuthority",
     "createBrowserDownloadArtifactDisposalAuthority",
+    "createVolcengineFunctionExecutionAuthority",
+    "createVolcengineFunctionProcessExecutionAuthority",
+    "createVolcengineFunctionRevocationAuthority",
+    "createVolcengineFunctionRevocationEvidenceResolver",
+    "createVolcengineFunctionReplayStore",
+    "createVolcengineFunctionRevocationStatusFloorStore",
   ];
   for (const name of providerFactories) {
     if (typeof factories[name] !== "function") continue;
@@ -912,6 +942,15 @@ function bindFactoriesToModule(factories, moduleDigest) {
       return factories.createEvolutionEvalProcessSupervisor(options);
     };
   }
+  if (typeof factories.createVolcengineFunctionProcessExecutor === "function") {
+    result.createVolcengineFunctionProcessExecutor = (options = {}) => {
+      if (options?.target?.handlerArtifactDigest !== moduleDigest)
+        throw new Error(
+          "Volcengine function process target handlerArtifactDigest must equal the authenticated deployment module digest",
+        );
+      return factories.createVolcengineFunctionProcessExecutor(options);
+    };
+  }
   return Object.freeze(result);
 }
 

package/src/lib/evolution/skill-writer-inventory-manifest.js

@@ -604,45 +604,6 @@ export const SKILL_WRITER_INVENTORY = Object.freeze({
         ],
       },
     }),
-    writer({
-      id: "desktop-skills-create-ipc",
-      surface: "desktop",
-      triggerClass: "manual",
-      targetAuthority: "legacy-active",
-      mutationType: "skill-bytes",
-      discoverySymbol: "ipc:skills:create",
-      entrypoint: {
-        file: "desktop-app-vue/src/main/ai-engine/cowork/skills/skills-ipc.js",
-        symbol: "ipc:skills:create",
-        evidence: ['ipcMain.handle("skills:create"'],
-      },
-      mutation: {
-        file: "desktop-app-vue/src/main/ai-engine/cowork/skills/skills-ipc.js",
-        symbol: "ipc:skills:create",
-        evidence: [
-          'path.join(targetDir, "SKILL.md")',
-          "await fs.writeFile(skillMdPath, content",
-        ],
-      },
-    }),
-    writer({
-      id: "desktop-skills-enabled-ipc",
-      surface: "desktop",
-      triggerClass: "manual",
-      targetAuthority: "legacy-active",
-      mutationType: "active-selection",
-      discoverySymbol: null,
-      entrypoint: {
-        file: "desktop-app-vue/src/main/ai-engine/cowork/skills/skills-ipc.js",
-        symbol: "ipc:skills:set-enabled",
-        evidence: ['ipcMain.handle("skills:set-enabled"'],
-      },
-      mutation: {
-        file: "desktop-app-vue/src/main/ai-engine/cowork/skills/skills-ipc.js",
-        symbol: "ipc:skills:set-enabled",
-        evidence: ["skill.config.enabled = enabled"],
-      },
-    }),
     writer({
       id: "desktop-skill-creator-create",
       surface: "desktop",