@nomix-ai/nomix-harness 0.2.5 → 0.2.6

package/dist/kernel/llm/lib/types/index.d.ts

@@ -6,7 +6,7 @@
  * @module @nomix-ai/nomix-llm
  */
 import { Context, Service } from '../../../cordis/lib/index.js';
-import type { GenerateOptions, LlmConfigurableProvider, LlmDiscoveredModel, LlmFailure, LlmModelContext, LlmModelDiscoveryRequest, LlmModelInfo, LlmResolvedModelInfo, LlmProviderInfo, StreamChunk } from './types.ts';
+import type { GenerateOptions, LlmConfigurableProvider, LlmDiscoveredModel, LlmFailure, LlmModelContext, LlmModelDiscoveryRequest, LlmModelInfo, LlmResolvedModelInfo, LlmProviderInfo, ModelModality, StreamChunk } from './types.ts';
 import type { ResolvedRetryPolicy } from './retry-policy.ts';
 import type { ProviderRequestId } from './brand.ts';
 import type { LlmCallConfig, LlmCallConfigAdapterDefaults } from './call-config.ts';
@@ -93,6 +93,8 @@ export interface PreparedLlmCall {
     readonly retryPolicy: ResolvedRetryPolicy;
     /** Detached context metadata resolved with the registration-bound call. */
     readonly context?: LlmModelContext;
+    /** Exact model modalities captured with the adapter dispatch generation. */
+    readonly inputModalities?: readonly ModelModality[];
     /** Config fields materialized by the captured adapter rather than proposed by the caller. */
     readonly adapterDefaults: LlmCallConfigAdapterDefaults;
     /**
@@ -104,6 +106,13 @@ export interface PreparedLlmCall {
      */
     stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
 }
+/** One adapter-owned model-resolution generation bound to its eventual stream call. */
+export interface PreparedAdapterCall {
+    /** Exact model metadata from the same adapter generation as {@link stream}. */
+    readonly model: LlmResolvedModelInfo;
+    /** Dispatch through that generation without re-reading dynamic connection facts. */
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+}
 /**
  * Provider-wire adapter for the harness message and stream vocabulary. Register implementations
  * with `ctx.llm.registerAdapter(providers, adapter)`. Every provider HTTP request must include
@@ -141,6 +150,16 @@ export declare abstract class LlmAdapter {
      * @returns provider/model identity plus any context, call-default, and reasoning metadata.
      */
     resolveModel(provider: string, model: string, _signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
+    /**
+     * Bind exact model metadata and the eventual request dispatch to one adapter generation.
+     * Dynamic adapters override this so settings changes between preparation and
+     * dispatch cannot combine one generation's capabilities with another's endpoint.
+     * @param provider - registered provider route.
+     * @param model - exact model id.
+     * @param signal - cancellation for model resolution.
+     * @returns model metadata and a one-generation stream entry point.
+     */
+    prepareCall(provider: string, model: string, signal?: AbortSignal): Promise<PreparedAdapterCall>;
     /**
      * Stream one model call as raw chunks. The only required method.
      * @param options - the fully-assembled request; implementations must honor `options.signal`.
@@ -293,6 +312,8 @@ export declare class LlmRuntime extends Service {
      */
     resolveModelInfo(provider: string, model: string, signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
     private resolveModelInfoFor;
+    /** Validate and detach one adapter-returned exact model result. */
+    private normalizeModelInfo;
     /**
      * Validate a conversation call config against its exact model capability and
      * materialize adapter-configured defaults. Unsupported explicit efforts
@@ -305,6 +326,8 @@ export declare class LlmRuntime extends Service {
      */
     resolveCallConfig(config: LlmCallConfig, signal?: AbortSignal): Promise<LlmCallConfig>;
     private resolveCallFor;
+    /** Validate request controls against one already-bound exact model result. */
+    private resolveCallWithInfo;
     /**
      * Resolve one call under its current adapter registration. The returned
      * one-shot handle keeps that registration across header logging and dispatch,

package/dist/kernel/llm/lib/types/index.js

@@ -12,6 +12,7 @@ import { callConfigEquals, deepFreeze } from "./call-config.js";
 import { HarnessError, INVALID_CREDENTIAL_CODE } from "./error.js";
 import { normalizeLlmFailure } from "./adapter-failure.js";
 import { normalizeApiKey } from "./api-key.js";
+import { contentHasImage, projectImagesForTextModel } from "./content.js";
 export * from "./attribution.js";
 export * from "./brand.js";
 export * from "./never.js";
@@ -140,6 +141,21 @@ export class LlmAdapter {
     resolveModel(provider, model, _signal) {
         return Promise.resolve({ provider, id: model, name: model });
     }
+    /**
+     * Bind exact model metadata and the eventual request dispatch to one adapter generation.
+     * Dynamic adapters override this so settings changes between preparation and
+     * dispatch cannot combine one generation's capabilities with another's endpoint.
+     * @param provider - registered provider route.
+     * @param model - exact model id.
+     * @param signal - cancellation for model resolution.
+     * @returns model metadata and a one-generation stream entry point.
+     */
+    async prepareCall(provider, model, signal) {
+        return {
+            model: await this.resolveModel(provider, model, signal),
+            stream: options => this.stream(options),
+        };
+    }
 }
 /**
  * The abstract `llm` service: an adapter registry plus a streaming model-call
@@ -466,8 +482,12 @@ export class LlmRuntime extends Service {
         return this.resolveModelInfoFor(this.registration(provider), model, signal);
     }
     async resolveModelInfoFor(registration, model, signal) {
+        const resolved = await registration.adapter.resolveModel(registration.provider.id, model, signal);
+        return this.normalizeModelInfo(registration, model, resolved);
+    }
+    /** Validate and detach one adapter-returned exact model result. */
+    normalizeModelInfo(registration, model, resolved) {
         const provider = registration.provider.id;
-        const resolved = await registration.adapter.resolveModel(provider, model, signal);
         if (typeof resolved.provider !== 'string'
             || resolved.provider !== provider
             || typeof resolved.id !== 'string'
@@ -547,6 +567,10 @@ export class LlmRuntime extends Service {
     }
     async resolveCallFor(registration, config, signal) {
         const info = await this.resolveModelInfoFor(registration, config.model, signal);
+        return this.resolveCallWithInfo(config, info);
+    }
+    /** Validate request controls against one already-bound exact model result. */
+    resolveCallWithInfo(config, info) {
         const defaulted = config.maxTokens === undefined && info.defaultMaxTokens !== undefined
             ? { ...config, maxTokens: info.defaultMaxTokens }
             : config;
@@ -571,6 +595,7 @@ export class LlmRuntime extends Service {
         return {
             config: resolvedConfig,
             ...info.context === undefined ? {} : { context: info.context },
+            modelInfo: info,
         };
     }
     /**
@@ -583,7 +608,9 @@ export class LlmRuntime extends Service {
      */
     async prepareCall(config, signal) {
         const registration = this.registration(config.provider);
-        const resolved = await this.resolveCallFor(registration, config, signal);
+        const adapterCall = await registration.adapter.prepareCall(config.provider, config.model, signal);
+        const modelInfo = this.normalizeModelInfo(registration, config.model, adapterCall.model);
+        const resolved = this.resolveCallWithInfo(config, modelInfo);
         const resolvedConfig = deepFreeze(structuredClone(resolved.config));
         const context = resolved.context === undefined
             ? undefined
@@ -602,6 +629,9 @@ export class LlmRuntime extends Service {
             retryPolicy: registration.retryPolicy,
             adapterDefaults,
             ...context === undefined ? {} : { context },
+            ...modelInfo.inputModalities === undefined
+                ? {}
+                : { inputModalities: Object.freeze([...modelInfo.inputModalities]) },
             stream: (options) => {
                 if (dispatched) {
                     throw new LlmError('a prepared LLM call can only be dispatched once', 'INVALID_PREPARED_CALL');
@@ -610,7 +640,12 @@ export class LlmRuntime extends Service {
                     throw new LlmError('prepared LLM call config changed before adapter dispatch', 'INVALID_PREPARED_CALL');
                 }
                 dispatched = true;
-                return this.streamWithRegistration(options, { registration, config: resolvedConfig });
+                return this.streamWithRegistration(options, {
+                    registration,
+                    config: resolvedConfig,
+                    modelInfo,
+                    dispatch: options => adapterCall.stream(options),
+                });
             },
         });
     }
@@ -647,9 +682,21 @@ export class LlmRuntime extends Service {
         let iterator;
         try {
             const registration = prepared?.registration ?? this.registration(options.provider);
-            const resolvedConfig = prepared === undefined
-                ? (await this.resolveCallFor(registration, options, options.signal)).config
-                : prepared.config;
+            const adapter = registration.adapter;
+            let modelInfo;
+            let resolvedConfig;
+            let dispatch;
+            if (prepared === undefined) {
+                const adapterCall = await adapter.prepareCall(options.provider, options.model, options.signal);
+                modelInfo = this.normalizeModelInfo(registration, options.model, adapterCall.model);
+                resolvedConfig = this.resolveCallWithInfo(options, modelInfo).config;
+                dispatch = options => adapterCall.stream(options);
+            }
+            else {
+                modelInfo = prepared.modelInfo;
+                resolvedConfig = prepared.config;
+                dispatch = prepared.dispatch;
+            }
             if (prepared !== undefined && !callConfigEquals(options, resolvedConfig)) {
                 throw new LlmError('prepared LLM call config changed before adapter dispatch', 'INVALID_PREPARED_CALL');
             }
@@ -658,8 +705,14 @@ export class LlmRuntime extends Service {
                 : Object.isFrozen(options)
                     ? deepFreeze({ ...options, ...resolvedConfig })
                     : { ...options, ...resolvedConfig };
-            const adapter = registration.adapter;
-            const stream = adapter.stream(this.forAdapter(resolvedOptions, adapter));
+            const projectedOptions = modelInfo.inputModalities !== undefined
+                && !modelInfo.inputModalities.includes('image')
+                && resolvedOptions.messages.some(message => contentHasImage(message.content))
+                ? Object.isFrozen(resolvedOptions)
+                    ? deepFreeze({ ...resolvedOptions, messages: projectImagesForTextModel(resolvedOptions.messages) })
+                    : { ...resolvedOptions, messages: projectImagesForTextModel(resolvedOptions.messages) }
+                : resolvedOptions;
+            const stream = dispatch(this.forAdapter(projectedOptions, adapter));
             iterator = stream[Symbol.asyncIterator]();
         }
         catch (error) {

package/dist/kernel/llm/lib/types/retry-policy.d.ts

@@ -20,7 +20,7 @@ export interface BackoffConfig {
 export interface NormalRetryPolicyConfig {
     /** Retry only configured transient failure codes. */
     mode: 'normal';
-    /** Maximum eligible retries after the first request (default 2). */
+    /** Maximum eligible retries after the first request (default 5). */
     maxRetries?: number;
     /** Stable failure codes eligible for this policy. */
     retryableCodes?: string[];

package/dist/kernel/llm/lib/types/retry-policy.js

@@ -9,7 +9,7 @@
 import z from '../../../schemastery/lib/index.mjs';
 import { MAX_TIMER_DELAY_MS } from '../../../timeout/lib/index.js';
 import { EMPTY_RESPONSE_CODE } from "./error.js";
-const DEFAULT_MAX_RETRIES = 2;
+const DEFAULT_MAX_RETRIES = 5;
 const DEFAULT_INITIAL_DELAY_MS = 500;
 const DEFAULT_MAX_DELAY_MS = 10_000;
 const DEFAULT_JITTER_RATIO = 0.1;
@@ -43,7 +43,11 @@ export const RetryPolicySchema = z.union([
 const NORMAL_POLICY_KEYS = new Set([
     'mode', 'maxRetries', 'retryableCodes', 'backoff',
 ]);
-const ALWAYS_POLICY_KEYS = new Set(['mode', 'backoff']);
+// Layered configuration can retain normal-only fields after switching modes;
+// always mode ignores those inactive values while still rejecting unknown keys.
+const ALWAYS_POLICY_KEYS = new Set([
+    'mode', 'maxRetries', 'retryableCodes', 'backoff',
+]);
 const BACKOFF_KEYS = new Set(['initialDelayMs', 'maxDelayMs', 'jitterRatio']);
 function validateKeys(value, allowed, path) {
     for (const key of Object.keys(value)) {

package/dist/kernel/llm/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-llm",
   "description": "Provider-neutral LLM service interface for the Nomix Harness",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },