opencode-swarm 7.127.1 → 7.129.0

package/dist/turbo/lean/integration.d.ts

@@ -1,3 +1,4 @@
+import { type ModelOverride } from '../../utils/model-dispatch-fallback';
 import { type LaneEvidence, listLaneEvidence, readPhaseEvidence, type ValidationArtifact } from './evidence';
 /**
  * Configuration options for phase critic dispatch.
@@ -113,7 +114,7 @@ export declare const _internals: {
     compileCriticPackage: typeof compileCriticPackage;
     parseCriticVerdict: typeof parseCriticVerdict;
     writeCriticEvidence: typeof writeCriticEvidence;
-    dispatchCriticAgent: (directory: string, pkg: CriticPackage, agentName: string, timeoutMs: number, parentSessionId?: string) => Promise<string>;
+    dispatchCriticAgent: (directory: string, pkg: CriticPackage, agentName: string, timeoutMs: number, parentSessionId?: string, model?: ModelOverride) => Promise<string>;
     resolveDefaultCriticAgent: typeof resolveDefaultCriticAgent;
     readReviewerEvidence: typeof readReviewerEvidence;
     listLaneEvidence: typeof listLaneEvidence;

package/dist/utils/inline-fallback-advancer.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Issue #1905: shared "inline fallback advancer" for bespoke dispatch loops that
+ * cannot use {@link dispatchWithModelFallback} because their retry semantics
+ * differ (e.g. retry-on-permanent, per-attempt session lifecycle, consecutive-
+ * failure counters).
+ *
+ * Before this helper, the advance block (resolve next → advance index → parse
+ * → skip-on-malformed → tag quota/transient reason → notify) was inlined in
+ * `src/full-auto/oversight.ts:543–579`. Issue #1905 adds a second copy at
+ * `src/hooks/full-auto-intercept.ts` (`dispatchCriticAndWriteEvent`). Extracting
+ * the block prevents the two copies from drifting — a future fix to the
+ * increment-before-parse ordering or the malformed-skip semantics applies to both.
+ *
+ * The helper is PURE: it resolves, parses, and classifies, then returns the
+ * result + invokes an `onAdopt` side-effect callback. It does NOT touch caller
+ * state (the loop's `modelOverride` / `modelUsedLabel` / `modelFallbackIndex`
+ * stay in the caller).
+ */
+import { type ModelOverride } from './model-dispatch-fallback';
+export interface AdvanceInlineFallbackOptions {
+    /**
+     * Resolve the 1-based fallback model as a `provider/model` string, or null
+     * when the fallback chain is exhausted. Typically wraps
+     * `resolveFallbackModel(baseRole, index, getSwarmAgents(swarmId))`.
+     */
+    resolveFallback: (fallbackIndex: number) => string | null;
+    /** Current fallback index (0 = primary / registered model). */
+    index: number;
+    /** The error from the just-failed attempt — used to tag the reason. */
+    lastError: unknown;
+    /**
+     * Notified when a fallback model is cleanly adopted (for advisory logging
+     * and telemetry). NOT called when the chain is exhausted or the entry is
+     * malformed. The adopted override is returned in the result's `adopted`
+     * field — callers read it there, not from this callback, so the info
+     * payload intentionally omits the parsed `ModelOverride` (it would be
+     * redundant with `result.adopted.override`).
+     */
+    onAdopt: (info: {
+        toModel: string;
+        fallbackIndex: number;
+        reason: 'quota' | 'transient_model_error';
+    }) => void;
+}
+export interface AdvanceInlineFallbackResult {
+    /** The new fallback index (always >= the input `index`). */
+    nextIndex: number;
+    /**
+     * The adopted fallback's raw string + parsed override, or `null` when no
+     * new model was adopted (chain exhausted OR malformed entry skipped).
+     *
+     * When `null`, the caller must NOT change its current `modelOverride` — the
+     * next retry continues on the same model. The index may still have advanced
+     * (malformed-entry skip case) so the entry is not re-resolved.
+     */
+    adopted: {
+        modelString: string;
+        override: ModelOverride;
+    } | null;
+}
+/**
+ * Advance the inline fallback chain by one step. Encapsulates the
+ * increment-before-parse + malformed-skip + reason-tagging logic shared by
+ * the bespoke dispatch loops in `oversight.ts` and `full-auto-intercept.ts`.
+ *
+ * Behavior:
+ *  - Chain exhausted (`resolveFallback(index + 1)` returns null):
+ *    `{ nextIndex: index, adopted: null }` — keep retrying the current model.
+ *  - Malformed entry (`parseModelString` throws or returns undefined):
+ *    `{ nextIndex: index + 1, adopted: null }` — index advances (so the entry
+ *    is not re-resolved next retry) but the override is NOT changed.
+ *  - Clean entry: `{ nextIndex: index + 1, adopted: { modelString, override } }`
+ *    — `onAdopt` is called with the quota/transient reason for side effects.
+ */
+export declare function advanceInlineFallback(opts: AdvanceInlineFallbackOptions): AdvanceInlineFallbackResult;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.127.1",
+	"version": "7.129.0",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",