akm-cli 0.9.16-alpha.1 → 0.9.16

package/dist/indexer/search/ranking.js

@@ -2,162 +2,84 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { stableFtsScore } from "../../core/lexical-score.js";
-import { getEntryById } from "../../storage/repositories/index-entries-repository.js";
 import { getUtilityScoresByIds } from "../../storage/repositories/index-utility-repository.js";
-import { groupUnitHitsByEntry } from "../../storage/repositories/units-repository.js";
 import { buildLexicalQueryPlan } from "./fts-query.js";
 import { lexicalNameTokens, structuralNameTokenMatch } from "./name-match.js";
 import { applyBeliefStateScoreCeiling, applyScoreContributors, applyUtilityContributors, defaultRankingContributors, defaultUtilityRankingContributors, } from "./ranking-contributors.js";
 /**
- * The pre-redesign lexical/semantic split (`combineSearchScores`, retired
- * with the units path but restored here — measured against `curate-golden`,
- * see docs/plans/index-redesign.md's Search section): with both present,
- * lexical evidence dominates and semantic refines it; nothing here is a new
- * tuned value.
+ * Lower bounds keep a lexical hit competitive with a vector-only neighbour;
+ * the upper bound deliberately leaves room for the ranking contributors that
+ * run after retrieval (notably the bounded graph boost).  This is a
+ * calibration for the one search pipeline, not a claim that BM25 is
+ * comparable across different queries or FTS tables.
  */
-const LEXICAL_WEIGHT = 0.7;
-const SEMANTIC_WEIGHT = 0.3;
 /**
- * `unit_texts.kind` is redundant with `fragmentId` nullity by construction
- * (A1's `deriveUnits`: ordinal 0 is always the one structured-fields "card"
- * unit; every fragment-derived unit carries a non-null `fragmentId`), so
- * `matchedUnit.kind` is derived here instead of a second table read.
- */
-function unitKindFromFragmentId(fragmentId) {
-    return fragmentId === null ? "card" : "fragment";
-}
-/**
- * Group lexical unit hits to entries via `entry_units`, keeping the
- * strongest (most negative bm25 — see `stableFtsScore`) unit per entry, not
- * merely the best-RANKED one: magnitude, not rank, is what `fuseByEntry`
- * scores on.
+ * Convert FTS5's negative BM25 value into the lexical contribution used by
+ * this pipeline.  The transform is fixed and monotone: it depends only on a
+ * row's own BM25 value, so appending weaker candidates cannot rewrite an
+ * existing row's score. FTS5 commonly emits relevance near 1e-6 for broad
+ * queries, so first put relevance on a log scale around that observed value.
+ * The shape constant intentionally makes the curve approach its ceiling
+ * slowly: rare-term scores retain separation instead of all reading as 0.8.
+ *
+ * FTS5 produces finite non-positive values in normal operation.  Keeping the
+ * defensive cases here finite makes this boundary safe if a driver or fixture
+ * hands us an invalid value: `-Infinity` is the strongest possible match,
+ * while NaN, +Infinity, and positive scores contribute no lexical evidence.
  */
-function groupLexicalHitsByEntry(db, hits) {
-    const best = new Map();
-    if (hits.length === 0)
-        return best;
-    const hashes = [...new Set(hits.map((hit) => hit.unitHash))];
-    const placeholders = hashes.map(() => "?").join(",");
-    const rows = db
-        .prepare(`SELECT entry_id AS entryId, fragment_id AS fragmentId, unit_hash AS unitHash FROM entry_units WHERE unit_hash IN (${placeholders})`)
-        .all(...hashes);
-    const ownersByHash = new Map();
-    for (const row of rows) {
-        const owners = ownersByHash.get(row.unitHash) ?? [];
-        owners.push({ entryId: row.entryId, fragmentId: row.fragmentId });
-        ownersByHash.set(row.unitHash, owners);
-    }
-    for (const hit of hits) {
-        for (const owner of ownersByHash.get(hit.unitHash) ?? []) {
-            const existing = best.get(owner.entryId);
-            if (!existing || hit.bm25 < existing.bm25) {
-                best.set(owner.entryId, {
-                    bm25: hit.bm25,
-                    unitHash: hit.unitHash,
-                    fragmentId: owner.fragmentId,
-                    lexicalMatch: hit.lexicalMatch,
-                });
-            }
-        }
+export function normalizeFtsScores(results) {
+    const ftsScoreMap = new Map();
+    for (const result of results) {
+        ftsScoreMap.set(result.id, { score: result.lexicalScore ?? stableFtsScore(result.bm25Score), result });
     }
-    return best;
-}
-/**
- * Which unit is reported as `matchedUnit`/`fragmentId`: a fixed priority
- * order by evidence strength — card (name/description/tags/hints, the
- * strongest, most structured signal), then fragment, then a vector
- * neighbor — never a magnitude comparison across the three. At least one of
- * the three is defined for every `entryId` this is called with.
- */
-function pickFusionWinner(cardHit, fragmentHit, semanticHit) {
-    if (cardHit)
-        return { unitHash: cardHit.unitHash, fragmentId: cardHit.fragmentId };
-    if (fragmentHit)
-        return { unitHash: fragmentHit.unitHash, fragmentId: fragmentHit.fragmentId };
-    const winner = semanticHit;
-    return { unitHash: winner.hash, fragmentId: winner.fragmentId };
-}
-/**
- * Cosine similarity from a `units_vec` L2 distance over normalized vectors —
- * exactly the retired `tryVecScores`' own conversion, guarded the same way:
- * `1 - distance²/2`, clamped at 0, non-finite results treated as no evidence.
- */
-function semanticCosine(distance) {
-    const raw = 1 - (distance * distance) / 2;
-    return Number.isFinite(raw) ? Math.max(0, raw) : 0;
+    return ftsScoreMap;
 }
-/**
- * Fuse the card-lexical, fragment-lexical (both `units_fts`) and semantic
- * (`units_vec`) unit-level result lists into one ranked entry list
- * (index-redesign-contract.md B3, restructured for field emphasis by B5f
- * item 2). Splitting lexical into two kind-scoped lists — rather than one
- * pool mixing card and fragment units — is what replaces the old per-column
- * BM25 weights (name 10x, description 5x, tags 3x, hints 2x, content 1x): a
- * card (name/description/tags/hints) match ranks within its own small pool
- * instead of racing every fragment's body text on raw BM25, so field
- * emphasis falls out of the units' structure with no weight tuned.
- *
- * Each list is first grouped to entries via `entry_units`, keeping that
- * list's own strongest unit per entry — `groupUnitHitsByEntry` from the
- * stage-1 unit store does this (by distance) for the semantic side;
- * `groupLexicalHitsByEntry` mirrors it (by bm25) for each lexical side.
- *
- * The fused score is MAGNITUDE, not reciprocal-rank fusion: rank-only fusion
- * was measured against the `curate-golden` gate fixture and lost to this —
- * see docs/plans/index-redesign.md's Search section for the table. Lexical
- * evidence is `stableFtsScore(bm25, population)` (the calibrated, monotone,
- * per-row transform — floor 0.3, ceiling 0.8), taken as the BEST of the
- * entry's card ("parent" population) and fragment ("fragment" population)
- * magnitudes; semantic evidence is cosine similarity. Combined the way the
- * pre-redesign `combineSearchScores` combined FTS and vector scores: with
- * both present, `lexical * 0.7 + semantic * 0.3`; lexical alone is itself;
- * semantic alone is `semantic * 0.3` (never enough alone to outrank a real
- * lexical hit's 0.3 floor). `matchedUnit` reports the unit by evidence
- * priority, not magnitude (see `pickFusionWinner`).
- */
-export function fuseByEntry(db, cardLexical, fragmentLexical, semantic, opts = {}) {
-    const cardByEntry = groupLexicalHitsByEntry(db, cardLexical);
-    const fragmentByEntry = groupLexicalHitsByEntry(db, fragmentLexical);
-    const semanticByEntry = groupUnitHitsByEntry(db, semantic);
-    const includeTypes = opts.typeFilter && opts.typeFilter.length > 0 ? new Set(opts.typeFilter) : null;
-    const excludeTypes = opts.excludeTypes && opts.excludeTypes.length > 0 ? new Set(opts.excludeTypes) : null;
-    const entryIds = new Set([...cardByEntry.keys(), ...fragmentByEntry.keys(), ...semanticByEntry.keys()]);
-    const results = [];
-    for (const entryId of entryIds) {
-        const cardHit = cardByEntry.get(entryId);
-        const fragmentHit = fragmentByEntry.get(entryId);
-        const semanticHit = semanticByEntry.get(entryId);
-        const lexicalHit = cardHit ?? fragmentHit;
-        const lexicalScore = Math.max(cardHit ? stableFtsScore(cardHit.bm25, "parent") : 0, fragmentHit ? stableFtsScore(fragmentHit.bm25, "fragment") : 0);
-        const semanticScore = semanticHit ? semanticCosine(semanticHit.distance) : undefined;
-        const score = lexicalHit
-            ? semanticScore === undefined
-                ? lexicalScore
-                : lexicalScore * LEXICAL_WEIGHT + semanticScore * SEMANTIC_WEIGHT
-            : (semanticScore ?? 0) * SEMANTIC_WEIGHT;
-        const { unitHash, fragmentId } = pickFusionWinner(cardHit, fragmentHit, semanticHit);
-        const found = getEntryById(db, entryId);
+export function combineSearchScores(options) {
+    const FTS_WEIGHT = 0.7;
+    const VEC_WEIGHT = 0.3;
+    const excludeTypeSet = options.excludeTypes && options.excludeTypes.length > 0 ? new Set(options.excludeTypes) : null;
+    const scored = [];
+    const seenIds = new Set();
+    for (const [id, { score: ftsScore, result }] of options.ftsScoreMap) {
+        seenIds.add(id);
+        const embedScore = options.embedScoreMap.get(id);
+        const combinedScore = embedScore !== undefined ? ftsScore * FTS_WEIGHT + embedScore * VEC_WEIGHT : ftsScore;
+        scored.push({
+            id,
+            entry: result.entry,
+            filePath: result.filePath,
+            score: combinedScore,
+            rankingMode: embedScore !== undefined ? "hybrid" : "fts",
+            lexicalMatch: result.lexicalMatch,
+            itemRef: result.itemRef,
+            bundleId: result.bundleId,
+            conceptId: result.conceptId,
+            fragmentId: result.fragmentId,
+        });
+    }
+    for (const [id, cosine] of options.embedScoreMap) {
+        if (seenIds.has(id))
+            continue;
+        const found = options.getEntryById(id);
         if (!found)
             continue;
-        if (includeTypes && !includeTypes.has(found.entry.type))
+        if (options.typeFilter && found.entry.type !== options.typeFilter)
             continue;
-        if (excludeTypes?.has(found.entry.type))
+        // #627 — drop vector-only neighbors whose type is excluded on the default path.
+        if (excludeTypeSet?.has(found.entry.type))
             continue;
-        results.push({
-            id: entryId,
+        scored.push({
+            id,
             entry: found.entry,
             filePath: found.filePath,
-            score,
-            rankingMode: lexicalHit && semanticHit ? "hybrid" : lexicalHit ? "fts" : "semantic",
+            score: cosine * VEC_WEIGHT,
+            rankingMode: "semantic",
             itemRef: found.itemRef,
             bundleId: found.bundleId,
             conceptId: found.conceptId,
-            ...(lexicalHit ? { lexicalMatch: lexicalHit.lexicalMatch } : {}),
-            ...(fragmentId ? { fragmentId } : {}),
-            matchedUnit: { unitHash, fragmentId, kind: unitKindFromFragmentId(fragmentId) },
         });
     }
-    return results;
+    return scored;
 }
 export function applyRankingRules(options) {
     const queryTokens = buildLexicalQueryPlan(options.query).tokens.map((token) => token.toLowerCase());

package/dist/indexer/search/search-source.js

@@ -4,7 +4,8 @@
 import fs from "node:fs";
 import path from "node:path";
 import { isWithin, resolveStashDir } from "../../core/common.js";
-import { bundleComponentConfig, bundlesToSourceEntries, getSources, loadConfig } from "../../core/config/config.js";
+import { bundleComponentConfig, bundleKeyForContentRoot, bundlesToSourceEntries, getSources, isBundleEnabled, loadConfig, } from "../../core/config/config.js";
+import { ConfigError } from "../../core/errors.js";
 import { getUnresolvedSourcesDir } from "../../core/paths.js";
 import { resolveGitContentRoot, resolveWritable } from "../../core/write-source.js";
 import { lockContentRootFor } from "../../integrations/lockfile.js";
@@ -23,7 +24,7 @@ import { warn } from "../../core/warn.js";
  *   2. The configured `defaultBundle`, after component-root validation.
  *   3. Remaining configured bundles in installation-priority order.
  *
- * Disabled entries (`enabled: false`) are filtered after deduplication.
+ * Disabled entries (`enabled: false`) are excluded before materialization.
  * Missing configured roots remain in the result so the
  * indexer can classify their scan as incomplete instead of mistaking them for
  * removed sources.
@@ -39,23 +40,39 @@ export function resolveSourceEntries(overrideStashDir, existingConfig) {
             : config.defaultBundle
                 ? undefined
                 : resolveStashDir();
+    const implicitConfiguredBundle = implicitStashDir ? bundleKeyForContentRoot(config, implicitStashDir) : undefined;
+    if (implicitConfiguredBundle && !isBundleEnabled(config, implicitConfiguredBundle)) {
+        throw new ConfigError(`The requested working source is disabled as bundle ${JSON.stringify(implicitConfiguredBundle)}.`, "INVALID_CONFIG_FILE");
+    }
     // Explicit and environment overrides stay first. Without either override,
     // the configured default enters through the validated loop below.
-    const sources = implicitStashDir ? [{ path: implicitStashDir, writable: true }] : [];
-    const seen = new Set(implicitStashDir ? [implicitStashDir] : []);
-    const addSource = (dir, registryId, writable, type, adapterId, unresolved = false) => {
+    const sources = implicitStashDir ? [{ path: implicitStashDir, writable: true, isDefault: true }] : [];
+    const sourceIdentity = (dir) => {
+        const resolved = path.resolve(dir);
+        try {
+            return fs.realpathSync.native(resolved);
+        }
+        catch {
+            return resolved;
+        }
+    };
+    const seen = new Set(implicitStashDir ? [sourceIdentity(implicitStashDir)] : []);
+    const addSource = (dir, registryId, writable, type, adapterId, unresolved = false, isDefault = false) => {
         const resolved = path.resolve(dir);
-        if (seen.has(resolved)) {
+        const identity = sourceIdentity(resolved);
+        if (seen.has(identity)) {
             // Already in the source list — typically the primary stash injected at
             // sources[0] before this loop. Enrich that entry with whatever metadata
             // the matching config source carries so `--from <config-name>` can
             // find it via registryId. Without this, the primary stash entry stays
             // identity-less and a user-named primary source ("name": "my-stash")
             // would validate but match zero entries when filtering.
-            const existing = sources.find((s) => s.path === resolved);
+            const existing = sources.find((source) => sourceIdentity(source.path) === identity);
             if (existing && existing.type === undefined) {
                 if (registryId)
                     existing.registryId = registryId;
+                if (isDefault)
+                    existing.isDefault = true;
                 existing.type = type;
                 existing.writable = writable;
                 existing.adapterId = adapterId;
@@ -64,13 +81,14 @@ export function resolveSourceEntries(overrideStashDir, existingConfig) {
                 existing.unresolved = true;
             return;
         }
-        seen.add(resolved);
+        seen.add(identity);
         if (isSuspiciousStashRoot(dir)) {
             warn(`Warning: stash root "${dir}" appears to be a system directory. This may be unintentional.`);
         }
         sources.push({
             path: resolved,
             ...(registryId ? { registryId } : {}),
+            ...(isDefault ? { isDefault: true } : {}),
             writable,
             type,
             ...(adapterId ? { adapterId } : {}),
@@ -88,17 +106,17 @@ export function resolveSourceEntries(overrideStashDir, existingConfig) {
         const contentRoot = resolveEntryContentDir(entry);
         if (contentRoot == null) {
             const unresolvedPath = path.join(getUnresolvedSourcesDir(implicitStashDir ?? process.cwd()), entry.name ?? entry.type);
-            addSource(unresolvedPath, entry.name, component?.writable ?? resolveWritable(entry), entry.type, component?.adapter, true);
+            addSource(unresolvedPath, entry.name, component?.writable ?? resolveWritable(entry), entry.type, component?.adapter, true, entry.name === config.defaultBundle);
             continue;
         }
         const dir = path.resolve(contentRoot, component?.root ?? ".");
         if (!isWithin(dir, contentRoot)) {
             warn(`Warning: component root "${component?.root}" escapes bundle "${entry.name}"; skipping source.`);
             const unresolvedPath = path.join(getUnresolvedSourcesDir(contentRoot), entry.name ?? entry.type);
-            addSource(unresolvedPath, entry.name, component?.writable ?? resolveWritable(entry), entry.type, component?.adapter, true);
+            addSource(unresolvedPath, entry.name, component?.writable ?? resolveWritable(entry), entry.type, component?.adapter, true, entry.name === config.defaultBundle);
             continue;
         }
-        addSource(dir, entry.name, component?.writable ?? resolveWritable(entry), entry.type, component?.adapter);
+        addSource(dir, entry.name, component?.writable ?? resolveWritable(entry), entry.type, component?.adapter, false, entry.name === config.defaultBundle);
     }
     return sources;
 }

package/dist/integrations/agent/execution-lowering.js

@@ -581,8 +581,9 @@ function lowerLlm(request, base) {
             (typeof tools === "object" && tools !== null && !Array.isArray(tools) && Object.keys(tools).length === 0);
         if (empty)
             translated.add("tools");
-        else
-            reject("tools");
+        else {
+            throw new ConfigError("The direct LLM transport cannot enforce the resolved tool policy.", "INVALID_CONFIG_FILE");
+        }
     }
     if (own(request.runtime, "workspace")) {
         if (request.runtime.workspace === null || request.runtime.workspace === "")

package/dist/integrations/agent/execution-preparation.js

@@ -9,6 +9,37 @@ import { loadModelMap } from "./model-map.js";
 function own(value, key) {
     return Object.hasOwn(value, key);
 }
+function requestedToolNames(tools) {
+    if (tools === null)
+        return Object.freeze([]);
+    if (typeof tools === "string") {
+        return Object.freeze(tools
+            .split(",")
+            .map((tool) => tool.trim())
+            .filter(Boolean));
+    }
+    if (Array.isArray(tools))
+        return Object.freeze(tools.map((tool) => tool.trim()).filter(Boolean));
+    const structured = tools;
+    // The portable structured spelling is a boolean allow/deny map. Opaque or
+    // nested provider policy cannot be reduced to tool names without guessing,
+    // so a host name allowlist must deny it (an explicit "*" may still allow it).
+    if (Object.values(structured).some((value) => typeof value !== "boolean"))
+        return undefined;
+    return Object.freeze(Object.keys(structured).filter((tool) => structured[tool] === true));
+}
+/** The production authorizer: executable assets may only narrow a host-owned ceiling. */
+export function toolAuthorizerFromConfig(config) {
+    const allowed = new Set(config.execution?.allowedTools ?? []);
+    return (input) => {
+        const requested = requestedToolNames(input.tools);
+        const permitted = allowed.has("*") || requested?.every((tool) => allowed.has(tool)) === true;
+        return Object.freeze({
+            status: permitted ? "allowed" : "denied",
+            policy: "config-execution-allowed-tools",
+        });
+    };
+}
 /** Pure common cascade composition once caller-specific sources are rendered. */
 export function planPreparedExecution(options) {
     return planExecutionCascade({
@@ -56,7 +87,7 @@ export function prepareResolvedExecution(options) {
         engines: executionEngineDefinitionsFromConfig(config),
         modelMap: options.modelMap ?? loadModelMap({ engines: config.engines }).map,
         invocationKind: options.invocationKind,
-        ...(options.authorizeTools ? { authorizeTools: options.authorizeTools } : {}),
+        authorizeTools: options.authorizeTools ?? toolAuthorizerFromConfig(config),
     });
     return Object.freeze({
         plan,

package/dist/integrations/agent/prompts.js

@@ -324,7 +324,7 @@ export function buildReflectPrompt(input) {
         sections.push(lines.join("\n"));
     }
     if (input.avoidPatterns && input.avoidPatterns.length > 0) {
-        sections.push(`## Avoid These Patterns\nPrevious assets in this run produced these errors — do not repeat them:\n${input.avoidPatterns.map((e) => `- ${e}`).join("\n")}`);
+        sections.push(`## Avoid These Patterns\nRun-only guidance: do not copy this heading, explanation, or any diagnostic below into the proposed asset.\nPrevious assets in this run produced these errors — do not repeat them:\n${input.avoidPatterns.map((e) => `- ${e}`).join("\n")}`);
     }
     // R-1 / #372: Self-Refine (arXiv:2303.17651) — inject prior draft as critique target.
     // On refinement iterations (iter > 0), the agent is shown its previous proposal

package/dist/integrations/agent/request-lowering.js

@@ -162,8 +162,9 @@ export function createAgentRequestLowerer(options) {
             const tools = request.tools;
             if (translatesTools(options.tools, tools))
                 translated.add("tools");
-            else
-                reject("tools");
+            else {
+                throw new ConfigError(`The ${options.adapter} transport cannot enforce the resolved tool policy.`, "INVALID_CONFIG_FILE");
+            }
             dispatch.tools = tools;
         }
         if (own(request.runtime, "settings")) {

package/dist/llm/client.js

@@ -444,11 +444,12 @@ async function chatCompletionAttemptOnce(config, messages, options, timeoutMs, i
  * attempts the schema request fresh every time and falls back once per call
  * on a 4xx — see the in-memory tracker below.
  */
-export async function probeLlmReachable(config) {
+export async function probeLlmReachable(config, timeoutMs) {
     try {
         const raw = await chatCompletion(config, [{ role: "user", content: "Respond with just the word: ok" }], {
             maxTokens: 16,
             temperature: 0,
+            ...(timeoutMs !== undefined ? { timeoutMs } : {}),
         });
         return raw.length > 0 ? { reachable: true } : { reachable: false, error: "empty response" };
     }
@@ -456,15 +457,6 @@ export async function probeLlmReachable(config) {
         return { reachable: false, error: err instanceof Error ? err.message : String(err) };
     }
 }
-/**
- * Default bound for a best-effort capability/reachability probe (#914):
- * generous enough for a cold local model server to answer a route-existence
- * check, short enough that `akm health --probe` and the provider-limits
- * probe (`src/llm/embedders/provider-limits.ts`, index-units) do not stall a
- * run on a dead endpoint. Shared so both probes bound themselves to the same
- * value instead of drifting apart.
- */
-export const HEALTH_PROBE_TIMEOUT_MS = 3_000;
 /**
  * Reachability probe for `akm health` (#914): one GET against the
  * OpenAI-compatible `/models` route, bounded by `timeoutMs`. Any HTTP
@@ -472,7 +464,7 @@ export const HEALTH_PROBE_TIMEOUT_MS = 3_000;
  * answers, not whether the route exists or the credential is right — so a
  * cold local server is never asked to load a model just to be checked.
  */
-export async function probeLlmEndpoint(config, timeoutMs = HEALTH_PROBE_TIMEOUT_MS) {
+export async function probeLlmEndpoint(config, timeoutMs = 3_000) {
     try {
         await fetch(`${config.endpoint.replace(/\/+$/, "")}/models`, { signal: AbortSignal.timeout(timeoutMs) });
         return { reachable: true };

package/dist/llm/embedder.js

@@ -104,17 +104,10 @@ async function embedOnce(text, embeddingConfig, signal) {
  * `onBatch`, when given, fires once per provider/local batch as it completes
  * (#954) so a caller can commit each batch's rows durably as they land
  * rather than buffering the whole call — see `EmbeddingBatchCommit`.
- *
- * `packing`, when given, threads a remote request's window/exact-token-
- * counter/Ollama `num_ctx` in from the provider's own probed limits
- * (`probeProviderLimits`, `src/llm/embedders/provider-limits.ts`) instead of
- * the retired `embedding.maxTokens`/`batchSize`/`contextLength` config keys
- * (index redesign, B5) — see `EmbeddingRequestPacking`. Only the remote
- * branch below consumes it; local/deterministic embedding ignores it.
  */
-export async function embedBatch(texts, embeddingConfig, signal, onSkip, onBatch, packing) {
+export async function embedBatch(texts, embeddingConfig, signal, onSkip, onBatch) {
     if (embedderOverrides?.embedBatch) {
-        return embedderOverrides.embedBatch(texts, embeddingConfig, signal, onSkip, onBatch, packing);
+        return embedderOverrides.embedBatch(texts, embeddingConfig, signal, onSkip, onBatch);
     }
     if (texts.length === 0)
         return [];
@@ -128,7 +121,7 @@ export async function embedBatch(texts, embeddingConfig, signal, onSkip, onBatch
         return embeddings;
     }
     if (embeddingConfig && hasRemoteEndpoint(embeddingConfig)) {
-        return new RemoteEmbedder(embeddingConfig).embedBatch(texts, signal, onSkip, onBatch, packing);
+        return new RemoteEmbedder(embeddingConfig).embedBatch(texts, signal, onSkip, onBatch);
     }
     // Local transformer: use the batched path (chunks of 32 via LocalEmbedder).
     // When a localModel override is set we cannot share the singleton (which uses