@wrongstack/core 0.310.1 → 0.313.1

package/dist/core/model-ref.js

@@ -1,26 +1,8 @@
-// src/core/model-ref.ts
-function parseModelRef(ref) {
-  const trimmed = ref.trim();
-  const slash = trimmed.indexOf("/");
-  if (slash !== -1) {
-    return {
-      provider: trimmed.slice(0, slash) || void 0,
-      model: trimmed.slice(slash + 1).trim()
-    };
-  }
-  const parts = trimmed.split(/\s+/);
-  if (parts.length >= 2) {
-    return { provider: parts[0], model: parts.slice(1).join(" ") };
-  }
-  return { model: trimmed };
-}
-function formatModelRef(ref, defaultProvider) {
-  const provider = ref.provider ?? defaultProvider;
-  return provider ? `${provider}/${ref.model}` : ref.model;
-}
-function normalizeModelRef(ref, defaultProvider) {
-  return formatModelRef(parseModelRef(ref), defaultProvider);
-}
+import {
+  formatModelRef,
+  normalizeModelRef,
+  parseModelRef
+} from "../chunk-RJIZEJ42.js";
 export {
   formatModelRef,
   normalizeModelRef,

package/dist/core/provider-runner.d.ts

@@ -1,9 +1,10 @@
+import type { ProviderModelStatusTracker } from '../coordination/provider-status-tracker.js';
 import type { EventBus } from '../kernel/events.js';
+import type { AgentContext } from '../types/context.js';
 import type { Logger } from '../types/logger.js';
 import type { Tracer } from '../types/observability.js';
 import type { Provider, Request, Response } from '../types/provider.js';
 import type { RetryPolicy } from '../types/retry-policy.js';
-import type { AgentContext } from '../types/context.js';
 export interface RunProviderOptions {
     provider: Provider;
     request: Request;
@@ -13,12 +14,46 @@ export interface RunProviderOptions {
     retry: RetryPolicy;
     logger: Logger;
     tracer?: Tracer | undefined;
+    /**
+     * Shared provider/model waiting room. When present this runner refuses to
+     * put a quarantined (provider, model) pair on the wire and reports every
+     * wire outcome back into it. See {@link runProviderWithRetry}.
+     */
+    statusTracker?: ProviderModelStatusTracker | undefined;
 }
+/**
+ * Marks a ProviderError whose failure has already been written to the waiting
+ * room, so an outer layer (the `fallback-model` extension) does not count the
+ * same wire failure twice. `Symbol.for` because the error crosses esbuild
+ * subpath-bundle boundaries where class identity is not preserved.
+ */
+export declare const PROVIDER_FAILURE_TRACKED: unique symbol;
+/** True when a previous layer already recorded this error in the waiting room. */
+export declare function isProviderFailureTracked(err: unknown): boolean;
 /**
  * Call a provider with the retry policy applied. Emits `provider.retry`
  * before each retry and `provider.error` once when the retries are
  * exhausted. Streaming providers route through the streaming-response
  * builder so deltas reach the renderer.
+ *
+ * ## Waiting-room middleware
+ *
+ * This function is the ONE funnel every agent-loop provider call passes
+ * through — leader turns, subagent turns, and every hop the `fallback-model`
+ * extension takes (its chain calls back into this runner). When
+ * `statusTracker` is supplied it therefore acts as the last line of defence
+ * for the provider waiting room:
+ *
+ * - **Pre-flight**: a quarantined (provider, model) pair never reaches the
+ *   wire. A synthetic fallback-worthy 429 is thrown instead, so an outer
+ *   fallback chain rotates to the next candidate exactly as it would for a
+ *   real rate limit — but no HTTP request, and no billing, happens.
+ * - **Post-flight**: every success and every terminal failure is recorded,
+ *   independent of which extensions are installed. Before this, the ONLY
+ *   writer was the `fallback-model` extension; anything running without it
+ *   (or any failure whose class identity did not survive a bundle boundary)
+ *   left the waiting room empty and the same doomed model was picked again
+ *   on the very next spawn.
  */
 export declare function runProviderWithRetry(opts: RunProviderOptions): Promise<Response>;
 //# sourceMappingURL=provider-runner.d.ts.map