@gmickel/gno 1.28.0 → 1.29.0

package/src/llm/httpEmbedding.ts

@@ -5,9 +5,12 @@
  * @module src/llm/httpEmbedding
  */
 
+import type { HttpInferenceOptions } from "./http-inference";
 import type { EmbeddingPort, LlmResult } from "./types";
 
-import { inferenceFailedError } from "./errors";
+import { EgressDeniedError } from "../core/egress-enforcement";
+import { egressDeniedInferenceError, inferenceFailedError } from "./errors";
+import { requestHttpInference } from "./http-inference";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Types
@@ -34,11 +37,13 @@ interface OpenAIEmbeddingResponse {
 export class HttpEmbedding implements EmbeddingPort {
   private readonly apiUrl: string;
   private readonly modelName: string;
+  private readonly requestOptions: HttpInferenceOptions;
   private dims: number | null = null;
   readonly modelUri: string;
 
-  constructor(modelUri: string) {
+  constructor(modelUri: string, requestOptions: HttpInferenceOptions) {
     this.modelUri = modelUri;
+    this.requestOptions = requestOptions;
     // Parse URI: http://host:port/v1/embeddings#modelname or just http://host:port
     const hashIndex = modelUri.indexOf("#");
     if (hashIndex > 0) {
@@ -64,16 +69,20 @@ export class HttpEmbedding implements EmbeddingPort {
 
   async embed(text: string): Promise<LlmResult<number[]>> {
     try {
-      const response = await fetch(this.apiUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
+      const response = await requestHttpInference(
+        this.apiUrl,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            input: text,
+            model: this.modelName,
+          }),
         },
-        body: JSON.stringify({
-          input: text,
-          model: this.modelName,
-        }),
-      });
+        this.requestOptions
+      );
 
       if (!response.ok) {
         const errorText = await response.text();
@@ -108,26 +117,33 @@ export class HttpEmbedding implements EmbeddingPort {
     } catch (e) {
       return {
         ok: false,
-        error: inferenceFailedError(
-          this.modelUri,
-          e instanceof Error ? e : new Error(String(e))
-        ),
+        error:
+          e instanceof EgressDeniedError
+            ? egressDeniedInferenceError(e)
+            : inferenceFailedError(
+                this.modelUri,
+                e instanceof Error ? e : new Error(String(e))
+              ),
       };
     }
   }
 
   async embedBatch(texts: string[]): Promise<LlmResult<number[][]>> {
     try {
-      const response = await fetch(this.apiUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
+      const response = await requestHttpInference(
+        this.apiUrl,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            input: texts,
+            model: this.modelName,
+          }),
         },
-        body: JSON.stringify({
-          input: texts,
-          model: this.modelName,
-        }),
-      });
+        this.requestOptions
+      );
 
       if (!response.ok) {
         const errorText = await response.text();
@@ -168,10 +184,13 @@ export class HttpEmbedding implements EmbeddingPort {
     } catch (e) {
       return {
         ok: false,
-        error: inferenceFailedError(
-          this.modelUri,
-          e instanceof Error ? e : new Error(String(e))
-        ),
+        error:
+          e instanceof EgressDeniedError
+            ? egressDeniedInferenceError(e)
+            : inferenceFailedError(
+                this.modelUri,
+                e instanceof Error ? e : new Error(String(e))
+              ),
       };
     }
   }

package/src/llm/httpGeneration.ts

@@ -5,12 +5,16 @@
  * @module src/llm/httpGeneration
  */
 
+import type { HttpInferenceOptions } from "./http-inference";
 import type { GenerationPort, GenParams, LlmResult } from "./types";
 
+import { EgressDeniedError } from "../core/egress-enforcement";
 import {
+  egressDeniedInferenceError,
   inferenceFailedError,
   structuredOutputUnavailableError,
 } from "./errors";
+import { requestHttpInference } from "./http-inference";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Types
@@ -44,11 +48,13 @@ interface OpenAIChatResponse {
 export class HttpGeneration implements GenerationPort {
   private readonly apiUrl: string;
   private readonly modelName: string;
+  private readonly requestOptions: HttpInferenceOptions;
   readonly modelUri: string;
   readonly structuredOutput = "none" as const;
 
-  constructor(modelUri: string) {
+  constructor(modelUri: string, requestOptions: HttpInferenceOptions) {
     this.modelUri = modelUri;
+    this.requestOptions = requestOptions;
     // Parse URI: http://host:port/v1/chat/completions#modelname
     const hashIndex = modelUri.indexOf("#");
     if (hashIndex > 0) {
@@ -74,20 +80,24 @@ export class HttpGeneration implements GenerationPort {
       };
     }
     try {
-      const response = await fetch(this.apiUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
+      const response = await requestHttpInference(
+        this.apiUrl,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            model: this.modelName,
+            messages: [{ role: "user", content: prompt }],
+            temperature: params?.temperature ?? 0,
+            max_tokens: params?.maxTokens ?? 256,
+            stop: params?.stop,
+            seed: params?.seed,
+          }),
         },
-        body: JSON.stringify({
-          model: this.modelName,
-          messages: [{ role: "user", content: prompt }],
-          temperature: params?.temperature ?? 0,
-          max_tokens: params?.maxTokens ?? 256,
-          stop: params?.stop,
-          seed: params?.seed,
-        }),
-      });
+        this.requestOptions
+      );
 
       if (!response.ok) {
         const errorText = await response.text();
@@ -107,10 +117,13 @@ export class HttpGeneration implements GenerationPort {
     } catch (e) {
       return {
         ok: false,
-        error: inferenceFailedError(
-          this.modelUri,
-          e instanceof Error ? e : new Error(String(e))
-        ),
+        error:
+          e instanceof EgressDeniedError
+            ? egressDeniedInferenceError(e)
+            : inferenceFailedError(
+                this.modelUri,
+                e instanceof Error ? e : new Error(String(e))
+              ),
       };
     }
   }

package/src/llm/httpRerank.ts

@@ -5,9 +5,12 @@
  * @module src/llm/httpRerank
  */
 
+import type { HttpInferenceOptions } from "./http-inference";
 import type { LlmResult, RerankPort, RerankScore } from "./types";
 
-import { inferenceFailedError } from "./errors";
+import { EgressDeniedError } from "../core/egress-enforcement";
+import { egressDeniedInferenceError, inferenceFailedError } from "./errors";
+import { requestHttpInference } from "./http-inference";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Types
@@ -36,10 +39,12 @@ export class HttpRerank implements RerankPort {
   private readonly apiUrl: string;
   private readonly modelName: string;
   private readonly instruction: string;
+  private readonly requestOptions: HttpInferenceOptions;
   readonly modelUri: string;
 
-  constructor(modelUri: string) {
+  constructor(modelUri: string, requestOptions: HttpInferenceOptions) {
     this.modelUri = modelUri;
+    this.requestOptions = requestOptions;
     // Parse URI: http://host:port/v1/completions#modelname
     const hashIndex = modelUri.indexOf("#");
     if (hashIndex > 0) {
@@ -109,19 +114,23 @@ export class HttpRerank implements RerankPort {
 
   private async scoreBatch(prompts: string[]): Promise<LlmResult<number[]>> {
     try {
-      const response = await fetch(this.apiUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
+      const response = await requestHttpInference(
+        this.apiUrl,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            model: this.modelName,
+            prompt: prompts, // Array of prompts for batching
+            max_tokens: 10, // Just need the score
+            temperature: 0, // Deterministic
+            stop: ["\n", "<"],
+          }),
         },
-        body: JSON.stringify({
-          model: this.modelName,
-          prompt: prompts, // Array of prompts for batching
-          max_tokens: 10, // Just need the score
-          temperature: 0, // Deterministic
-          stop: ["\n", "<"],
-        }),
-      });
+        this.requestOptions
+      );
 
       if (!response.ok) {
         const errorText = await response.text();
@@ -154,10 +163,13 @@ export class HttpRerank implements RerankPort {
     } catch (e) {
       return {
         ok: false,
-        error: inferenceFailedError(
-          this.modelUri,
-          e instanceof Error ? e : new Error(String(e))
-        ),
+        error:
+          e instanceof EgressDeniedError
+            ? egressDeniedInferenceError(e)
+            : inferenceFailedError(
+                this.modelUri,
+                e instanceof Error ? e : new Error(String(e))
+              ),
       };
     }
   }

package/src/llm/index.ts

@@ -14,6 +14,7 @@ export type { LlmError, LlmErrorCode } from "./errors";
 export {
   corruptedError,
   downloadFailedError,
+  egressDeniedInferenceError,
   inferenceFailedError,
   invalidUriError,
   isRetryable,

package/src/llm/nodeLlamaCpp/adapter.ts

@@ -43,11 +43,22 @@ export interface CreatePortOptions {
   policy?: DownloadPolicy;
   /** Progress callback for downloads */
   onProgress?: ProgressCallback;
+  /**
+   * Participating collection scope for outbound HTTP inference.
+   * `"all"` is an explicit corpus-wide decision, never an omission fallback.
+   */
+  egressCollections: readonly string[] | "all";
 }
 
 /** Default policy: no auto-download (backwards compatible) */
 const DEFAULT_POLICY: DownloadPolicy = { offline: false, allowDownload: false };
 
+const resolveEgressCollectionNames = (
+  config: Config,
+  scope: CreatePortOptions["egressCollections"]
+): readonly string[] =>
+  scope === "all" ? config.collections.map(({ name }) => name) : scope;
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Adapter
 // ─────────────────────────────────────────────────────────────────────────────
@@ -70,16 +81,22 @@ export class LlmAdapter {
    * With options.policy.allowDownload=true, auto-downloads if not cached.
    */
   async createEmbeddingPort(
-    modelUri?: string,
-    options?: CreatePortOptions
+    modelUri: string | undefined,
+    options: CreatePortOptions
   ): Promise<LlmResult<EmbeddingPort>> {
     const preset = getActivePreset(this.config);
     const uri = modelUri ?? preset.embed;
-    const policy = options?.policy ?? DEFAULT_POLICY;
+    const policy = options.policy ?? DEFAULT_POLICY;
 
     // Use HTTP embedding for remote endpoints
     if (isHttpModelUri(uri)) {
-      const httpEmbed = new HttpEmbedding(uri);
+      const httpEmbed = new HttpEmbedding(uri, {
+        collections: this.config.collections,
+        collectionNames: resolveEgressCollectionNames(
+          this.config,
+          options.egressCollections
+        ),
+      });
       // Initialize to verify connection and get dimensions
       const initResult = await httpEmbed.init();
       if (!initResult.ok) {
@@ -93,7 +110,7 @@ export class LlmAdapter {
       uri,
       "embed",
       policy,
-      options?.onProgress
+      options.onProgress
     );
     if (!resolved.ok) {
       return resolved;
@@ -111,15 +128,21 @@ export class LlmAdapter {
    * With options.policy.allowDownload=true, auto-downloads if not cached.
    */
   async createGenerationPort(
-    modelUri?: string,
-    options?: CreatePortOptions
+    modelUri: string | undefined,
+    options: CreatePortOptions
   ): Promise<LlmResult<GenerationPort>> {
     const uri = getAnswerModelUri(this.config, modelUri);
-    const policy = options?.policy ?? DEFAULT_POLICY;
+    const policy = options.policy ?? DEFAULT_POLICY;
 
     // Use HTTP generation for remote endpoints
     if (isHttpGenUri(uri)) {
-      const httpGen = new HttpGeneration(uri);
+      const httpGen = new HttpGeneration(uri, {
+        collections: this.config.collections,
+        collectionNames: resolveEgressCollectionNames(
+          this.config,
+          options.egressCollections
+        ),
+      });
       return { ok: true, value: httpGen };
     }
 
@@ -128,7 +151,7 @@ export class LlmAdapter {
       uri,
       "gen",
       policy,
-      options?.onProgress
+      options.onProgress
     );
     if (!resolved.ok) {
       return resolved;
@@ -145,14 +168,20 @@ export class LlmAdapter {
    * Uses preset.expand when configured, else falls back to preset.gen.
    */
   async createExpansionPort(
-    modelUri?: string,
-    options?: CreatePortOptions
+    modelUri: string | undefined,
+    options: CreatePortOptions
   ): Promise<LlmResult<GenerationPort>> {
     const uri = getExpandModelUri(this.config, modelUri);
-    const policy = options?.policy ?? DEFAULT_POLICY;
+    const policy = options.policy ?? DEFAULT_POLICY;
 
     if (isHttpGenUri(uri)) {
-      const httpGen = new HttpGeneration(uri);
+      const httpGen = new HttpGeneration(uri, {
+        collections: this.config.collections,
+        collectionNames: resolveEgressCollectionNames(
+          this.config,
+          options.egressCollections
+        ),
+      });
       return { ok: true, value: httpGen };
     }
 
@@ -160,7 +189,7 @@ export class LlmAdapter {
       uri,
       "expand",
       policy,
-      options?.onProgress
+      options.onProgress
     );
     if (!resolved.ok) {
       return resolved;
@@ -178,16 +207,22 @@ export class LlmAdapter {
    * With options.policy.allowDownload=true, auto-downloads if not cached.
    */
   async createRerankPort(
-    modelUri?: string,
-    options?: CreatePortOptions
+    modelUri: string | undefined,
+    options: CreatePortOptions
   ): Promise<LlmResult<RerankPort>> {
     const preset = getActivePreset(this.config);
     const uri = modelUri ?? preset.rerank;
-    const policy = options?.policy ?? DEFAULT_POLICY;
+    const policy = options.policy ?? DEFAULT_POLICY;
 
     // Use HTTP rerank for remote endpoints
     if (isHttpRerankUri(uri)) {
-      const httpRerank = new HttpRerank(uri);
+      const httpRerank = new HttpRerank(uri, {
+        collections: this.config.collections,
+        collectionNames: resolveEgressCollectionNames(
+          this.config,
+          options.egressCollections
+        ),
+      });
       return { ok: true, value: httpRerank };
     }
 
@@ -196,7 +231,7 @@ export class LlmAdapter {
       uri,
       "rerank",
       policy,
-      options?.onProgress
+      options.onProgress
     );
     if (!resolved.ok) {
       return resolved;

package/src/llm/pinned-http-connection.ts

@@ -0,0 +1,177 @@
+/** Opaque request seam for one DNS-pinned HTTP connection. */
+
+import type { DestinationClassificationAudit } from "../core/destination-classifier";
+
+export interface HttpDestinationPolicyAudit {
+  protocol: "http" | "https" | "unknown";
+  port: number | null;
+  redirectCount: number;
+  classification: DestinationClassificationAudit;
+}
+
+export type PinnedHttpFetch = (
+  input: string | URL | Request,
+  init?: BunFetchRequestInit
+) => Promise<Response>;
+
+export class PinnedHttpRequestError extends Error {
+  readonly code = "PINNED_HTTP_REQUEST_FAILED";
+  readonly aborted: boolean;
+
+  constructor(aborted: boolean) {
+    super(
+      aborted ? "Pinned HTTP request aborted" : "Pinned HTTP request failed"
+    );
+    this.name = "PinnedHttpRequestError";
+    this.aborted = aborted;
+    this.stack = `${this.name}: ${this.message}`;
+  }
+
+  toJSON(): { code: string; message: string; aborted: boolean } {
+    return { code: this.code, message: this.message, aborted: this.aborted };
+  }
+}
+
+function freezeAudit(
+  audit: HttpDestinationPolicyAudit
+): HttpDestinationPolicyAudit {
+  const classification = Object.freeze({
+    ...audit.classification,
+    addressClasses: Object.freeze([...audit.classification.addressClasses]),
+  });
+  return Object.freeze({ ...audit, classification });
+}
+
+function normalizedRequestError(
+  signal?: AbortSignal | null
+): PinnedHttpRequestError {
+  return new PinnedHttpRequestError(signal?.aborted === true);
+}
+
+function releaseReaderLock(
+  reader: ReadableStreamDefaultReader<Uint8Array>
+): void {
+  try {
+    reader.releaseLock();
+  } catch {
+    // The sanitized stream is already terminal; never replace its safe error.
+  }
+}
+
+function sanitizeResponseBody(
+  body: ReadableStream<Uint8Array> | null,
+  signal?: AbortSignal | null
+): ReadableStream<Uint8Array> | null {
+  if (!body) return null;
+  const reader = body.getReader();
+  return new ReadableStream<Uint8Array>({
+    async pull(controller): Promise<void> {
+      try {
+        const chunk = await reader.read();
+        if (chunk.done) {
+          releaseReaderLock(reader);
+          controller.close();
+          return;
+        }
+        controller.enqueue(chunk.value);
+      } catch {
+        releaseReaderLock(reader);
+        controller.error(normalizedRequestError(signal));
+      }
+    },
+    async cancel(reason): Promise<void> {
+      try {
+        await reader.cancel(reason);
+        releaseReaderLock(reader);
+      } catch {
+        releaseReaderLock(reader);
+        throw normalizedRequestError(signal);
+      }
+    },
+  });
+}
+
+function buildPinnedRequestInit(
+  init: BunFetchRequestInit,
+  headers: Headers,
+  tls: BunFetchRequestInitTLS
+): BunFetchRequestInit {
+  return {
+    body: init.body,
+    cache: init.cache,
+    credentials: init.credentials,
+    decompress: init.decompress,
+    headers,
+    integrity: init.integrity,
+    keepalive: init.keepalive,
+    method: init.method,
+    mode: init.mode,
+    priority: init.priority,
+    redirect: "manual",
+    referrer: init.referrer,
+    referrerPolicy: init.referrerPolicy,
+    signal: init.signal,
+    tls,
+    verbose: false,
+    window: init.window,
+  };
+}
+
+/**
+ * JSON/log projection is redacted. request() is the only raw target consumer;
+ * it preserves Host/SNI while forcing an IP URL and manual redirects.
+ */
+export class PinnedHttpConnection {
+  readonly #targetUrl: string;
+  readonly #hostHeader: string;
+  readonly #tlsServerName?: string;
+  readonly #audit: HttpDestinationPolicyAudit;
+
+  constructor(
+    targetUrl: string,
+    hostHeader: string,
+    tlsServerName: string | undefined,
+    audit: HttpDestinationPolicyAudit
+  ) {
+    this.#targetUrl = targetUrl;
+    this.#hostHeader = hostHeader;
+    this.#tlsServerName = tlsServerName;
+    this.#audit = freezeAudit(audit);
+  }
+
+  toJSON(): { audit: HttpDestinationPolicyAudit; pinned: true } {
+    return { audit: this.#audit, pinned: true };
+  }
+
+  async request(
+    init: BunFetchRequestInit = {},
+    fetchFn: PinnedHttpFetch = fetch
+  ): Promise<Response> {
+    const headers = new Headers(init.headers);
+    headers.set("host", this.#hostHeader);
+    const {
+      checkServerIdentity: _ignoredIdentityOverride,
+      rejectUnauthorized: _ignoredVerificationOverride,
+      serverName: _ignoredServerNameOverride,
+      ...callerTls
+    } = init.tls ?? {};
+    const tls = {
+      ...callerTls,
+      rejectUnauthorized: true,
+      serverName: this.#tlsServerName,
+    };
+    try {
+      const response = await fetchFn(
+        this.#targetUrl,
+        buildPinnedRequestInit(init, headers, tls)
+      );
+      return new Response(sanitizeResponseBody(response.body, init.signal), {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+      });
+    } catch {
+      throw normalizedRequestError(init.signal);
+    }
+  }
+}