chainlesschain 0.166.46 → 0.166.47

package/src/lib/evolution/governed-hub-llm.js

@@ -1,13 +1,244 @@
 import { createRequire } from "node:module";
+import { types } from "node:util";
 import { prepareGovernedModelTurn } from "./governed-model-turn.js";
 
 const { createAuthenticatedEvolutionModelClient } = createRequire(
   import.meta.url,
 )("@chainlesschain/personal-data-hub/model-egress-guard");
+const { OllamaClient } = createRequire(import.meta.url)(
+  "@chainlesschain/personal-data-hub/llm-client",
+);
+const { CcLLMAdapter } = createRequire(import.meta.url)(
+  "@chainlesschain/personal-data-hub/bridges/cc-llm-adapter",
+);
+const { EntityResolverEmbeddingStage } = createRequire(import.meta.url)(
+  "@chainlesschain/personal-data-hub/entity-resolver",
+);
+
+const DEFAULT_SDK_PORTS = Object.freeze({
+  createAuthenticatedEvolutionModelClient,
+  OllamaClient,
+  CcLLMAdapter,
+  EntityResolverEmbeddingStage,
+});
+
+// A packaged Desktop has its own physical SDK copy and private client brand.
+// These main-process module exports select that copy, not Evolution authority.
+// Keep them separate from caller model/skill options; the factory below still
+// has to produce a genuinely branded, Run-bound composition on every call.
+export function captureGovernedHubSdkPorts(ports = DEFAULT_SDK_PORTS) {
+  if (
+    !ports ||
+    typeof ports !== "object" ||
+    Array.isArray(ports) ||
+    types.isProxy(ports)
+  )
+    throw new TypeError("Host Hub SDK ports must be an object");
+  const captured = {};
+  for (const name of Object.keys(DEFAULT_SDK_PORTS)) {
+    const descriptor = Object.getOwnPropertyDescriptor(ports, name);
+    if (
+      !descriptor ||
+      !Object.hasOwn(descriptor, "value") ||
+      typeof descriptor.value !== "function" ||
+      types.isProxy(descriptor.value)
+    )
+      throw new TypeError(
+        `Host Hub SDK ${name} must be a function data property`,
+      );
+    captured[name] = descriptor.value;
+  }
+  return Object.freeze(captured);
+}
+
+function isLoopbackEndpoint(value) {
+  if (typeof value !== "string") return false;
+  try {
+    const endpoint = new URL(value);
+    return (
+      ["http:", "https:"].includes(endpoint.protocol) &&
+      (endpoint.hostname === "localhost" ||
+        endpoint.hostname === "[::1]" ||
+        /^127(?:\.\d{1,3}){3}$/.test(endpoint.hostname))
+    );
+  } catch {
+    return false;
+  }
+}
+
+// These transports stay private to the invocation wrapper. The SDK's public
+// chat methods remain default-denied; only the wrapper below can hand this
+// transport messages after a branded composition has projected them.
+function captureHubTransport(llm, sdk) {
+  if (
+    llm instanceof sdk.OllamaClient &&
+    llm.chat === sdk.OllamaClient.prototype.chat
+  ) {
+    const { baseUrl, model, timeoutMs, _fetch: fetchImpl } = llm;
+    return {
+      // The SDK labels Ollama as local even for a remote baseUrl. Preserve
+      // stricter host policy, but never let that label waive cloud consent.
+      isLocal: isLoopbackEndpoint(baseUrl),
+      assertIdentity() {
+        if (
+          llm.baseUrl !== baseUrl ||
+          llm.model !== model ||
+          llm.timeoutMs !== timeoutMs ||
+          llm._fetch !== fetchImpl
+        )
+          throw new Error(
+            "Hub model identity changed; reopen the analysis invocation",
+          );
+      },
+      async chat(messages, options) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+          const signal = options.signal
+            ? AbortSignal.any([controller.signal, options.signal])
+            : controller.signal;
+          const response = await fetchImpl(`${baseUrl}/api/chat`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            redirect: "error",
+            signal,
+            body: JSON.stringify({
+              model,
+              messages,
+              stream: false,
+              options: {
+                temperature: options.temperature ?? 0.2,
+                ...(options.numCtx ? { num_ctx: options.numCtx } : {}),
+              },
+            }),
+          });
+          if (!response.ok)
+            throw new Error(
+              `Hub Ollama request failed: HTTP ${response.status}`,
+            );
+          const data = await response.json();
+          if (
+            data?.error ||
+            data?.done !== true ||
+            typeof data?.message?.content !== "string"
+          )
+            throw new Error(
+              "Hub Ollama response did not contain a completed text answer",
+            );
+          return {
+            text: data.message.content,
+            model,
+            usage: {
+              promptTokens: data.prompt_eval_count ?? 0,
+              completionTokens: data.eval_count ?? 0,
+              totalTokens:
+                (data.prompt_eval_count ?? 0) + (data.eval_count ?? 0),
+            },
+          };
+        } finally {
+          clearTimeout(timer);
+        }
+      },
+    };
+  }
+  if (
+    llm instanceof sdk.CcLLMAdapter &&
+    llm.chat === sdk.CcLLMAdapter.prototype.chat
+  ) {
+    const chat = llm._chat;
+    const getActiveClient = llm._getActiveClient;
+    const getActiveProvider = llm._getActiveProvider;
+    const getActiveModel = llm._getActiveModel;
+    const provider = getActiveProvider?.();
+    const model = getActiveModel?.();
+    const client = getActiveClient?.();
+    const networkIdentity = {
+      baseURL: client?.baseURL,
+      host: client?.host,
+      model: client?.model,
+      chat: client?.chat,
+    };
+    const httpClient = client?.client;
+    const defaults = httpClient?.defaults;
+    const httpIdentity = {
+      baseURL: defaults?.baseURL,
+      post: httpClient?.post,
+      request: httpClient?.request,
+    };
+    const endpoint = networkIdentity.baseURL || networkIdentity.host;
+    if (httpClient && endpoint && httpIdentity.baseURL !== endpoint) {
+      const error = new Error(
+        "Hub Desktop endpoint does not match its selected HTTP client",
+      );
+      error.code = "CC_AGENT_EVOLUTION_INGRESS_FAILED";
+      throw error;
+    }
+    return {
+      // A provider label such as "ollama" does not establish locality. The
+      // host must expose its selected client; absent URL evidence is remote.
+      isLocal:
+        isLoopbackEndpoint(endpoint) &&
+        (!httpClient || httpIdentity.baseURL === endpoint),
+      assertIdentity() {
+        if (
+          llm._chat !== chat ||
+          llm._getActiveClient !== getActiveClient ||
+          llm._getActiveProvider !== getActiveProvider ||
+          llm._getActiveModel !== getActiveModel ||
+          getActiveProvider?.() !== provider ||
+          getActiveModel?.() !== model ||
+          getActiveClient?.() !== client ||
+          client?.client !== httpClient ||
+          httpClient?.defaults !== defaults ||
+          defaults?.baseURL !== httpIdentity.baseURL ||
+          httpClient?.post !== httpIdentity.post ||
+          httpClient?.request !== httpIdentity.request ||
+          Object.entries(networkIdentity).some(
+            ([key, value]) => client?.[key] !== value,
+          )
+        )
+          throw new Error(
+            "Hub model identity changed; reopen the analysis invocation",
+          );
+      },
+      async chat(messages, options) {
+        const result = await chat(messages, options);
+        const text =
+          result?.content ??
+          result?.text ??
+          result?.message?.content ??
+          result?.choices?.[0]?.message?.content;
+        if (typeof text !== "string")
+          throw new Error("Hub Desktop response must contain text");
+        const usage = result?.usage ?? {};
+        const promptTokens =
+          usage.promptTokens ?? usage.prompt_tokens ?? usage.input_tokens ?? 0;
+        const completionTokens =
+          usage.completionTokens ??
+          usage.completion_tokens ??
+          usage.output_tokens ??
+          0;
+        return {
+          text,
+          model: result.model,
+          usage: {
+            promptTokens,
+            completionTokens,
+            totalTokens:
+              usage.totalTokens ??
+              usage.total_tokens ??
+              promptTokens + completionTokens,
+          },
+        };
+      },
+    };
+  }
+  return { assertIdentity() {}, chat: llm.chat.bind(llm) };
+}
 
 // A scoped wrapper preserves the Hub's independent local/cloud consent check.
 // Never replace llm on the process-wide cached Hub or its analysis engine.
-export function createGovernedHubLlm(llm, factory, options = {}) {
+export function createGovernedHubLlm(llm, factory, options = {}, sdkPorts) {
   if (
     !llm ||
     typeof llm.chat !== "function" ||
@@ -21,7 +252,9 @@ export function createGovernedHubLlm(llm, factory, options = {}) {
     throw new TypeError("A Hub evolution factory is required");
   if (options.onFailure != null && typeof options.onFailure !== "function")
     throw new TypeError("onFailure must be a function");
+  const sdk = captureGovernedHubSdkPorts(sdkPorts);
   const identity = { name: llm.name, isLocal: llm.isLocal, chat: llm.chat };
+  const transport = captureHubTransport(llm, sdk);
   const assertIdentity = () => {
     if (
       llm.name !== identity.name ||
@@ -32,16 +265,16 @@ export function createGovernedHubLlm(llm, factory, options = {}) {
         "Hub model identity changed; reopen the analysis invocation",
       );
     }
+    transport.assertIdentity();
   };
-  const chat = identity.chat.bind(llm);
-  return createAuthenticatedEvolutionModelClient({
+  return sdk.createAuthenticatedEvolutionModelClient({
     getName() {
       assertIdentity();
       return identity.name;
     },
     getIsLocal() {
       assertIdentity();
-      return identity.isLocal;
+      return identity.isLocal && transport.isLocal !== false;
     },
     async prepare(messages, chatOptions = {}) {
       assertIdentity();
@@ -53,7 +286,7 @@ export function createGovernedHubLlm(llm, factory, options = {}) {
     },
     async transport(messages, chatOptions = {}) {
       assertIdentity();
-      const response = await chat(messages, chatOptions);
+      const response = await transport.chat(messages, chatOptions);
       assertIdentity();
       return response;
     },

package/src/lib/evolution/governed-hub-resolver.js

@@ -1,7 +1,79 @@
 import { prepareGovernedModelTurn } from "./governed-model-turn.js";
-import { createGovernedHubLlm } from "./governed-hub-llm.js";
+import {
+  captureGovernedHubSdkPorts,
+  createGovernedHubLlm,
+} from "./governed-hub-llm.js";
 
-export function createGovernedHubResolver(ports, factory) {
+function captureEmbeddingTransport(stage, sdk) {
+  const {
+    _embed: embed,
+    _embedFn: embedFn,
+    _ollamaUrl: baseUrl,
+    _model: model,
+  } = stage;
+  const defaultOllama =
+    stage instanceof sdk.EntityResolverEmbeddingStage &&
+    embed === sdk.EntityResolverEmbeddingStage.prototype._embed &&
+    !embedFn;
+  if (defaultOllama) {
+    const endpoint = new URL(baseUrl);
+    if (
+      !["http:", "https:"].includes(endpoint.protocol) ||
+      !(
+        endpoint.hostname === "localhost" ||
+        endpoint.hostname === "[::1]" ||
+        /^127(?:\.\d{1,3}){3}$/.test(endpoint.hostname)
+      )
+    ) {
+      // Resolver drain has no explicit remote-embedding consent contract.
+      // Restoring the local backend must not silently authorize remote input.
+      const error = new Error(
+        "Default Hub embeddings require a loopback endpoint; remote embedding consent is not supported",
+      );
+      error.code = "CC_AGENT_EVOLUTION_INGRESS_FAILED";
+      throw error;
+    }
+  }
+  const fetchImpl = defaultOllama ? globalThis.fetch : null;
+  return {
+    assertIdentity() {
+      if (
+        stage._embed !== embed ||
+        stage._embedFn !== embedFn ||
+        stage._ollamaUrl !== baseUrl ||
+        stage._model !== model
+      )
+        throw new Error(
+          "Hub embedding identity changed; reopen the resolver invocation",
+        );
+    },
+    async embed(profile) {
+      if (!defaultOllama) return await embed.call(stage, profile);
+      // The raw SDK ollamaEmbed remains closed. This private transport is only
+      // invoked below, after the scoped Run projected the profile.
+      const response = await fetchImpl(
+        `${baseUrl.replace(/\/$/, "")}/api/embeddings`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          redirect: "error",
+          signal: AbortSignal.timeout(60_000),
+          body: JSON.stringify({ model, prompt: profile }),
+        },
+      );
+      if (!response.ok)
+        throw new Error(
+          `Hub embedding request failed: HTTP ${response.status}`,
+        );
+      const data = await response.json();
+      if (data?.error)
+        throw new Error("Hub embedding provider returned an error");
+      return data?.embedding;
+    },
+  };
+}
+
+export function createGovernedHubResolver(ports, factory, sdkPorts) {
   if (typeof factory !== "function")
     throw new TypeError("A resolver evolution factory is required");
   const {
@@ -12,6 +84,9 @@ export function createGovernedHubResolver(ports, factory) {
     EmbeddingStage,
     LLMStage,
   } = ports;
+  const sdk = captureGovernedHubSdkPorts(sdkPorts);
+  const transport =
+    embeddingStage && captureEmbeddingTransport(embeddingStage, sdk);
   // Rebuild stages for each drain. Neither the shared resolver nor its embedding
   // cache may acquire the authority of an individual WebSocket request.
   const embedding =
@@ -19,6 +94,7 @@ export function createGovernedHubResolver(ports, factory) {
     new EmbeddingStage({
       vault: resolver.vault,
       embedFn: async (profile) => {
+        transport.assertIdentity();
         const turn = await prepareGovernedModelTurn(factory, {
           mode: "hub-embedding",
           messages: [{ role: "user", content: profile }],
@@ -35,7 +111,9 @@ export function createGovernedHubResolver(ports, factory) {
           throw new Error(
             "Projected embedding input must contain one text message",
           );
-        const vector = await embeddingStage._embed(profileMessage.content);
+        transport.assertIdentity();
+        const vector = await transport.embed(profileMessage.content);
+        transport.assertIdentity();
         if (
           (!Array.isArray(vector) && !(vector instanceof Float32Array)) ||
           vector.length === 0 ||
@@ -51,7 +129,7 @@ export function createGovernedHubResolver(ports, factory) {
   const model =
     resolver._llmStage &&
     new LLMStage({
-      llm: createGovernedHubLlm(llm, factory),
+      llm: createGovernedHubLlm(llm, factory, {}, sdk),
       acceptNonLocal: false,
     });
   return new EntityResolver({

package/src/lib/evolution/governed-hub-skill.js

@@ -8,15 +8,21 @@ export async function runGovernedHubSkill(
   runSkill,
   name,
   options,
+  sdkPorts,
 ) {
   let failure;
   let failed = false;
-  const llm = createGovernedHubLlm(hub.llm, factory, {
-    onFailure(error) {
-      failure = error;
-      failed = true;
+  const llm = createGovernedHubLlm(
+    hub.llm,
+    factory,
+    {
+      onFailure(error) {
+        failure = error;
+        failed = true;
+      },
     },
-  });
+    sdkPorts,
+  );
   const result = await runSkill({ vault: hub.vault, llm }, name, options);
   if (failed) throw failure;
   return result;

package/src/lib/evolution/governed-skill-synthesis-provider-chat.js

@@ -7,6 +7,7 @@ const PORTS = new WeakSet();
 const OPTION_KEYS = new Set([
   "apiKey",
   "baseUrl",
+  "evolutionIngress",
   "maxTokens",
   "model",
   "provider",
@@ -185,7 +186,15 @@ export function createGovernedSkillSynthesisProviderChat(options = {}) {
     128,
     4_096,
   );
-  const chat = createChatFn({ provider, model, baseUrl, apiKey });
+  const chat = createChatFn({
+    provider,
+    model,
+    baseUrl,
+    apiKey,
+    ...(options.evolutionIngress == null
+      ? {}
+      : { evolutionIngress: options.evolutionIngress }),
+  });
 
   const port = async (messages) => {
     const controller = new AbortController();