@chatpanel/events 0.78.2 → 0.79.0

package/cowriter-router.js

@@ -36,8 +36,11 @@ function withTierAndMode(c) {
 }
 
 // Appoint one role → the best available candidate (or null if none usable).
-export function appoint(role, candidates, { overrides = {} } = {}) {
-  const usable = (candidates || []).filter((c) => c && c.usable !== false && c.model);
+export function appoint(role, candidates, { overrides = {}, exclude = null } = {}) {
+  // `exclude` — ids (or model names) that failed this run: the next appointment is the
+  // nearest tier among what is left, which is what a person would do by hand.
+  const out = exclude ? new Set(exclude) : null;
+  const usable = (candidates || []).filter((c) => c && c.usable !== false && c.model && !(out && (out.has(c.id) || out.has(c.model))));
   if (!usable.length) return null;
   const ovId = overrides[role.id];
   if (ovId) {

package/index.js

@@ -195,7 +195,7 @@ export { createBudget, validateBudget, normalizeBudget, usageOf, BudgetError, BU
 export { defineTeam, validateTeam, normalizeTeam, normalizeGrants, grantAllows, describeRole, TeamError, ROLE_MODES, MERGE_POLICIES, PLAN_MODES, GRANTABLE, STARTER_TEAMS, starterTeams, blankTeam, teamFromForm, slugTeamName } from './team.js';
 export { fixedPlan, parsePlan, plannerPrompt, waves, breakCycles, TEAM_PLAN_SCHEMA } from './team-plan.js';
 export { createBoard, parseFindings, boardText, findingsInstruction, toBriefClaims, FINDINGS_SCHEMA, FINDING_KINDS } from './team-board.js';
-export { runTeam, dryRunTeam, TeamRunError, RUN_STATUSES } from './team-run.js';
+export { runTeam, dryRunTeam, isModelUnavailable, TeamRunError, RUN_STATUSES } from './team-run.js';
 export { teamToolProvider, teamToolSpec, describeTeamForApproval, TEAM_TOOL_NAME } from './team-tool.js';
 export { teamLine, teamLanes } from './team-trail.js';
 export { mcpDispatchProvider, MCP_TOOL_NAME } from './mcp-dispatch.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/events",
-  "version": "0.78.2",
+  "version": "0.79.0",
   "description": "The canonical ChatPanel event-log and capability contracts \u2014 typed durable facts, clock-free deterministic linearization, schema upcasting, and the invariants the replay harness asserts. Pure, dependency-free ESM shared by the ChatPanel extension, gateway and bridge.",
   "type": "module",
   "main": "index.js",

package/team-run.js

@@ -44,6 +44,16 @@ const strongestRole = (team) => [...team.roles].sort((a, b) => (TIER[b.prefer] ?
  * What a person sees before approving a run: every role with the model it would get, its
  * grants and mode; the plan when it is fixed (a planner plans at run time); the budget.
  */
+/**
+ * Was this failure the MODEL being unreachable — not found, not deployed, no key, gone —
+ * rather than the request being wrong? The runner re-appoints on these and gives up on the
+ * rest. Provider wording varies; what they share is that a different model would answer.
+ */
+export function isModelUnavailable(error) {
+  const m = String(error?.message || error || '');
+  return /model[_ ]not[_ ]found|not found|not deployed|inaccessible|does not exist|no such model|unknown model|unsupported model|not available|unavailable|no api key|not configured|"status":\s*(404|401|403)\b|\b(404|401|403)\b/i.test(m);
+}
+
 export function dryRunTeam(team, request, { appoint = null } = {}) {
   const t = normalizeTeam(team);
   const roles = t.roles.map((r) => {
@@ -85,7 +95,13 @@ export async function runTeam({
   const tasksOut = [];
   const say = (type, payload = {}) => emit(type, { runId: id, at: now(), ...payload });
   const roleOf = (rid) => t.roles.find((r) => r.id === rid);
-  const modelFor = (r) => (appoint ? appoint(r) : null) || (r.model ? { model: r.model, mode: r.mode } : null);
+  // `exclude` holds what failed as unavailable this run; a re-appointment skips it. A role's
+  // pinned model is tried first and, when it is the one that failed, the roster steps in.
+  const modelFor = (r, exclude = null) => {
+    if (exclude?.size && r.model && exclude.has(r.model)) return appoint ? appoint({ ...r, model: undefined }, { exclude }) : null;
+    return (appoint ? appoint(r, { exclude }) : null) || (r.model && !exclude?.has(r.model) ? { model: r.model, mode: r.mode } : null);
+  };
+  const MAX_APPOINTMENTS = 3;
   const stopped = () => !!signal?.aborted;
 
   say('run.started', { team: t.name, request: String(request || ''), budget: t.budget, roles: t.roles.map((r) => r.id) });
@@ -132,8 +148,6 @@ export async function runTeam({
           const r = await runRecipe(role.recipe, { request: String(request || ''), task: task.prompt });
           text = typeof r === 'string' ? r : JSON.stringify(r);
         } else {
-          const m = modelFor(role);
-          if (!m?.model) throw new Error(`no model for role "${role.id}"`);
           // A call's tokens are unknown until it returns; what can be asked beforehand is
           // whether the budget is already exhausted and whether one more call is allowed.
           if (!budget.canAfford({ tokens: 0 })) { overBudget = true; throw new Error('over budget'); }
@@ -141,16 +155,27 @@ export async function runTeam({
           const prompt = [task.prompt, prior, findingsInstruction()].filter(Boolean).join('\n\n');
           // A host may build a toolset asynchronously (connecting MCP servers takes time).
           const tools = await toolsFor(role);
-          const res = await callModel({
-            runId: id, taskId: task.id, role: role.id, model: m.model, mode: m.mode || role.mode,
-            system: role.prompt, prompt, tools, signal,
-            onDelta: (delta, full) => say('task.delta', { taskId: task.id, role: role.id, delta, text: full }),
-          });
-          usage = res?.usage || null;
-          if (usage) budget.charge(usage);
-          if (res?.aborted) { status = 'stopped'; }
-          else if (!res?.ok) throw new Error(res?.error || 'the model did not answer');
-          text = String(res?.text || '');
+          // A model that is not there — not deployed, no key, gone — is not the task failing:
+          // the next model on the roster is appointed and the task tried again, up to three
+          // models. Anything else (a refusal, a timeout, a bad request) fails the task.
+          const exclude = new Set();
+          for (let attempt = 1; ; attempt++) {
+            const m = modelFor(role, exclude);
+            if (!m?.model) throw new Error(exclude.size ? `no model left for role "${role.id}" after ${[...exclude].join(', ')}` : `no model for role "${role.id}"`);
+            if (attempt > 1) say('task.reappointed', { taskId: task.id, role: role.id, model: m.model, after: [...exclude] });
+            const res = await callModel({
+              runId: id, taskId: task.id, role: role.id, model: m.model, mode: m.mode || role.mode,
+              system: role.prompt, prompt, tools, signal,
+              onDelta: (delta, full) => say('task.delta', { taskId: task.id, role: role.id, delta, text: full }),
+            });
+            usage = res?.usage || null;
+            if (usage) budget.charge(usage);
+            if (res?.aborted) { status = 'stopped'; break; }
+            if (res?.ok) { text = String(res?.text || ''); break; }
+            const err = res?.error || 'the model did not answer';
+            if (attempt >= MAX_APPOINTMENTS || stopped() || !isModelUnavailable(err)) throw new Error(err);
+            exclude.add(m.model);
+          }
         }
       } catch (e) {
         status = overBudget ? 'over-budget' : 'failed';

package/team-tool.js

@@ -16,8 +16,12 @@ import { dryRunTeam } from './team-run.js';
 
 export const TEAM_TOOL_NAME = 'team';
 
+// The teams the model may see and run: enabled, named, and whole. A record another client
+// half-wrote (a name and nothing else) is not a team — Settings shows it for deleting.
+const usable = (teams) => (teams || []).filter((t) => t?.name && t.enabled !== false && validateTeam(t).ok);
+
 function catalogue(teams) {
-  const list = (teams || []).filter((t) => t && t.enabled !== false && t.name);
+  const list = usable(teams);
   if (!list.length) return 'No teams saved yet.';
   return `Saved teams: ${list.map((t) => `${t.name} (${(t.roles || []).map((r) => r.id).join(', ')})${t.description ? ` — ${t.description}` : ''}`).join('; ')}.`;
 }
@@ -66,7 +70,7 @@ const json = (v) => JSON.stringify(v);
  * @param saveTeam     `async (team) => void`
  */
 export function teamToolProvider({ teams = [], run = null, appoint = null, confirmSave = null, saveTeam = null } = {}) {
-  const byName = new Map((teams || []).filter((t) => t?.name && t.enabled !== false).map((t) => [t.name, t]));
+  const byName = new Map(usable(teams).map((t) => [t.name, t]));
   let bound = null;
   return {
     id: 'team',

package/team-trail.js

@@ -10,6 +10,7 @@ export function teamLine(ev) {
     case 'run.started': return { type: 'status', text: `team ${ev.team}: ${(ev.roles || []).join(', ')}` };
     case 'plan.ready': return { type: 'status', text: `plan: ${(ev.tasks || []).length} task${(ev.tasks || []).length === 1 ? '' : 's'} (${ev.by})` };
     case 'task.started': return { type: 'tool', name: role, text: `${role} · ${ev.title || ev.taskId}` };
+    case 'task.reappointed': return { type: 'status', text: `${role} → ${ev.model} (${(ev.after || []).join(', ')} unavailable)` };
     case 'task.tool': return { type: 'tool', name: ev.name, text: `${role} ran ${ev.name}${ev.text ? ` — ${ev.text}` : ''}` };
     case 'task.finding': return { type: 'status', text: `${role}: ${String(ev.finding?.text || '').slice(0, 140)}` };
     case 'task.done': return { type: 'status', text: `${role} done · ${ev.findings || 0} finding${ev.findings === 1 ? '' : 's'}` };