@voybio/ace-swarm 2.4.0 → 2.4.1

package/dist/tools-framework.js

@@ -21,6 +21,7 @@ import { auditStoreAuthority, writeStoreAuthorityAuditReport, } from "./store/st
 import { PROVENANCE_CRITICAL_EVENT_TYPES, validateArtifactManifestPayload, validateProvenanceLogContent, validateTealConfigContent, } from "./schemas.js";
 import { readAceTaskContractAssessment } from "./ace-autonomy.js";
 import { listStoreKeysSync, readStoreBlobSync } from "./store/store-snapshot.js";
+import { parseJsonLikeText } from "./json-sanitizer.js";
 function executionRoleForDomain(domain) {
     switch (domain) {
         case "venture":
@@ -75,6 +76,14 @@ function parseGateManifest(raw, sourceRef) {
         return undefined;
     }
 }
+function parseJsonForValidation(raw) {
+    return parseJsonLikeText(raw);
+}
+function jsonValidationDetail(parsed, validDetail = "valid JSON") {
+    return parsed.sanitized.removed_control_bytes > 0
+        ? `control bytes removed before parse (${parsed.sanitized.removed_control_bytes}); source requires repair`
+        : validDetail;
+}
 function readGateManifests(gatesDir) {
     const files = readdirSync(gatesDir).filter((f) => f.endsWith(".json"));
     const allGates = [];
@@ -737,7 +746,10 @@ export function registerFrameworkTools(server) {
                                 "",
                                 "## LLM Runtime Profile",
                                 `- provider: ${llm_provider}`,
-                                `- model: ${resolvedLlmModel ?? defaultModelForProvider(llm_provider)}`,
+                                `- model: ${resolvedLlmModel ??
+                                    (llm_provider === "llama.cpp"
+                                        ? "(set via ace connect or ace doctor --scan)"
+                                        : defaultModelForProvider(llm_provider))}`,
                                 `- base_url: ${resolvedLlmBaseUrl ??
                                     (llm_provider === "ollama" || llm_provider === "llama.cpp"
                                         ? "discover via ace doctor --scan or set explicitly"
@@ -1010,58 +1022,60 @@ export function registerFrameworkTools(server) {
         // Check: handoff registry parseable
         const hrRaw = safeRead("agent-state/handoff-registry.json");
         const hrOk = !hrRaw.startsWith("[FILE NOT FOUND]");
+        let hrParsed;
         if (hrOk) {
-            try {
-                JSON.parse(hrRaw);
+            const parsed = parseJsonForValidation(hrRaw);
+            if (parsed.ok) {
+                hrParsed = parsed.value;
                 checks.push({
                     name: "handoff-registry:parse",
-                    ok: true,
-                    detail: "valid JSON",
+                    ok: parsed.sanitized.removed_control_bytes === 0,
+                    detail: jsonValidationDetail(parsed),
                 });
             }
-            catch {
+            else {
                 checks.push({
                     name: "handoff-registry:parse",
                     ok: false,
-                    detail: "CORRUPT JSON",
+                    detail: `agent-state/handoff-registry.json: ${parsed.error}`,
                 });
             }
         }
         // Check: run-ledger parseable
         const rlRaw = safeRead("agent-state/run-ledger.json");
         if (!rlRaw.startsWith("[FILE NOT FOUND]")) {
-            try {
-                JSON.parse(rlRaw);
+            const parsed = parseJsonForValidation(rlRaw);
+            if (parsed.ok) {
                 checks.push({
                     name: "run-ledger:parse",
-                    ok: true,
-                    detail: "valid JSON",
+                    ok: parsed.sanitized.removed_control_bytes === 0,
+                    detail: jsonValidationDetail(parsed),
                 });
             }
-            catch {
+            else {
                 checks.push({
                     name: "run-ledger:parse",
                     ok: false,
-                    detail: "CORRUPT JSON",
+                    detail: `agent-state/run-ledger.json: ${parsed.error}`,
                 });
             }
         }
         // Check: todo-state parseable
         const tsRaw = safeRead("agent-state/todo-state.json");
         if (!tsRaw.startsWith("[FILE NOT FOUND]")) {
-            try {
-                JSON.parse(tsRaw);
+            const parsed = parseJsonForValidation(tsRaw);
+            if (parsed.ok) {
                 checks.push({
                     name: "todo-state:parse",
-                    ok: true,
-                    detail: "valid JSON",
+                    ok: parsed.sanitized.removed_control_bytes === 0,
+                    detail: jsonValidationDetail(parsed),
                 });
             }
-            catch {
+            else {
                 checks.push({
                     name: "todo-state:parse",
                     ok: false,
-                    detail: "CORRUPT JSON",
+                    detail: `agent-state/todo-state.json: ${parsed.error}`,
                 });
             }
         }
@@ -1081,19 +1095,19 @@ export function registerFrameworkTools(server) {
                 });
                 continue;
             }
-            try {
-                JSON.parse(raw);
+            const parsed = parseJsonForValidation(raw);
+            if (parsed.ok) {
                 checks.push({
                     name: check.name,
-                    ok: true,
-                    detail: "valid JSON",
+                    ok: parsed.sanitized.removed_control_bytes === 0,
+                    detail: jsonValidationDetail(parsed),
                 });
             }
-            catch {
+            else {
                 checks.push({
                     name: check.name,
                     ok: false,
-                    detail: "CORRUPT JSON",
+                    detail: `${check.rel}: ${parsed.error}`,
                 });
             }
         }
@@ -1147,25 +1161,28 @@ export function registerFrameworkTools(server) {
         const artifactManifestRaw = safeRead("agent-state/ARTIFACT_MANIFEST.json");
         let artifactManifestEntries = [];
         if (!artifactManifestRaw.startsWith("[FILE NOT FOUND]")) {
-            try {
-                const parsed = JSON.parse(artifactManifestRaw);
-                const validation = validateArtifactManifestPayload(parsed);
+            const parsed = parseJsonForValidation(artifactManifestRaw);
+            if (parsed.ok) {
+                const validation = validateArtifactManifestPayload(parsed.value);
+                const controlBytesOk = parsed.sanitized.removed_control_bytes === 0;
                 checks.push({
                     name: "artifact-manifest:schema",
-                    ok: validation.ok,
-                    detail: validation.ok
-                        ? `valid (${validation.schema})`
-                        : validation.errors.join("; "),
+                    ok: validation.ok && controlBytesOk,
+                    detail: !controlBytesOk
+                        ? jsonValidationDetail(parsed)
+                        : validation.ok
+                            ? `valid (${validation.schema})`
+                            : validation.errors.join("; "),
                 });
                 if (validation.ok) {
-                    artifactManifestEntries = getArtifactManifestEntries(parsed);
+                    artifactManifestEntries = getArtifactManifestEntries(parsed.value);
                 }
             }
-            catch {
+            else {
                 checks.push({
                     name: "artifact-manifest:parse",
                     ok: false,
-                    detail: "CORRUPT JSON",
+                    detail: `agent-state/ARTIFACT_MANIFEST.json: ${parsed.error}`,
                 });
             }
         }
@@ -1203,8 +1220,16 @@ export function registerFrameworkTools(server) {
         // Check: module registry role coverage vs event emitters
         const registryRaw = safeRead("agent-state/MODULES/registry.json");
         if (!registryRaw.startsWith("[FILE NOT FOUND]")) {
-            try {
-                const registry = JSON.parse(registryRaw);
+            const parsed = parseJsonForValidation(registryRaw);
+            if (parsed.ok) {
+                if (parsed.sanitized.removed_control_bytes > 0) {
+                    checks.push({
+                        name: "registry:parse",
+                        ok: false,
+                        detail: jsonValidationDetail(parsed),
+                    });
+                }
+                const registry = parsed.value;
                 const registeredRoles = new Set(registry.roles ?? []);
                 const expectedEmitters = [
                     "capability-safety",
@@ -1223,11 +1248,11 @@ export function registerFrameworkTools(server) {
                     });
                 }
             }
-            catch {
+            else {
                 checks.push({
                     name: "registry:parse",
                     ok: false,
-                    detail: "registry.json is corrupt",
+                    detail: `agent-state/MODULES/registry.json: ${parsed.error}`,
                 });
             }
         }
@@ -1248,30 +1273,24 @@ export function registerFrameworkTools(server) {
             });
         }
         // Check: handoff consistency (open handoffs have source files)
-        if (hrOk) {
-            try {
-                const registry = JSON.parse(hrRaw);
-                const handoffs = Object.values(registry.handoffs ?? {});
-                let openWithoutFile = 0;
-                for (const h of handoffs) {
-                    if ((h.status === "open" || h.status === "accepted") &&
-                        h.source_file) {
-                        const fileContent = safeRead(h.source_file);
-                        if (fileContent.startsWith("[FILE NOT FOUND]"))
-                            openWithoutFile++;
-                    }
+        if (hrOk && hrParsed) {
+            const handoffs = Object.values(hrParsed.handoffs ?? {});
+            let openWithoutFile = 0;
+            for (const h of handoffs) {
+                if ((h.status === "open" || h.status === "accepted") &&
+                    h.source_file) {
+                    const fileContent = safeRead(h.source_file);
+                    if (fileContent.startsWith("[FILE NOT FOUND]"))
+                        openWithoutFile++;
                 }
-                checks.push({
-                    name: "handoff:source-file-integrity",
-                    ok: openWithoutFile === 0,
-                    detail: openWithoutFile === 0
-                        ? "all open handoffs have source files"
-                        : `${openWithoutFile} open handoffs reference missing source files`,
-                });
-            }
-            catch {
-                /* already caught above */
             }
+            checks.push({
+                name: "handoff:source-file-integrity",
+                ok: openWithoutFile === 0,
+                detail: openWithoutFile === 0
+                    ? "all open handoffs have source files"
+                    : `${openWithoutFile} open handoffs reference missing source files`,
+            });
         }
         // Check: event provenance gaps in recent events.
         // Scans for provenance-critical event types that are missing

package/dist/tui/index.js

@@ -56,7 +56,13 @@ export class AceTui {
         const workspaceRoot = options.workspaceRoot ?? WORKSPACE_ROOT;
         this.workspaceRoot = workspaceRoot;
         this.provider = this.normalizeProvider(options.provider ?? inferProviderFromModel(options.model) ?? "ollama") ?? "ollama";
-        this.model = (options.model ?? defaultModelForProvider(this.provider)).trim();
+        const initialModel = options.model ??
+            (this.provider === "ollama"
+                ? defaultModelForProvider(this.provider)
+                : this.provider === "llama.cpp"
+                    ? ""
+                    : defaultModelForProvider(this.provider));
+        this.model = initialModel.trim();
         // Initialize modules
         const colorLevel = detectColorLevel();
         for (const [provider, baseUrl] of Object.entries(options.providerBaseUrls ?? {})) {
@@ -757,6 +763,9 @@ export class AceTui {
         else if (this.provider === "ollama") {
             this.model = DEFAULT_OLLAMA_MODEL;
         }
+        else if (this.provider === "llama.cpp") {
+            this.model = "";
+        }
         else {
             this.model = defaultModelForProvider(this.provider);
         }

package/dist/tui/ollama.d.ts

@@ -111,6 +111,13 @@ export declare class OllamaClient {
 export declare class OllamaError extends Error {
     statusCode: number;
     responseBody: string;
-    constructor(message: string, statusCode: number, responseBody: string);
+    kind?: string;
+    meta?: Record<string, unknown>;
+    suggested_remediation?: string;
+    constructor(message: string, statusCode: number, responseBody: string, options?: {
+        kind?: string;
+        model?: string;
+        suggested_remediation?: string;
+    });
 }
 //# sourceMappingURL=ollama.d.ts.map

package/dist/tui/ollama.js

@@ -5,6 +5,24 @@
  * Zero dependencies — uses Node.js built-in fetch/http.
  * Supports model listing, pulling, chat streaming, and health checks.
  */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function requestedModelFromOptions(options) {
+    if (typeof options?.body !== "string")
+        return undefined;
+    try {
+        const parsed = JSON.parse(options.body);
+        return typeof parsed.model === "string"
+            ? parsed.model
+            : typeof parsed.name === "string"
+                ? parsed.name
+                : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 // ── Client ───────────────────────────────────────────────────────────
 export class OllamaClient {
     baseUrl;
@@ -124,19 +142,36 @@ export class OllamaClient {
             throw new OllamaError("Ollama base URL is not configured. Set one explicitly or run `ace doctor --scan`.", 0, "");
         }
         const url = `${this.baseUrl}${path}`;
-        const res = await fetch(url, {
-            ...options,
-            headers: {
-                "Content-Type": "application/json",
-                Accept: "application/json",
-                ...(options?.headers ?? {}),
-            },
-        });
-        if (!res.ok) {
+        const maxAttempts = 3;
+        let lastError;
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+            const res = await fetch(url, {
+                ...options,
+                headers: {
+                    "Content-Type": "application/json",
+                    Accept: "application/json",
+                    ...(options?.headers ?? {}),
+                },
+            });
+            if (res.ok)
+                return res;
             const text = await res.text().catch(() => "");
-            throw new OllamaError(`Ollama API error: ${res.status} ${res.statusText}`, res.status, text);
+            const requestedModel = requestedModelFromOptions(options);
+            if (res.status >= 500 && /unable to load model/i.test(text)) {
+                throw new OllamaError(`Ollama was unable to load model${requestedModel ? ` '${requestedModel}'` : ""}. ` +
+                    `Run \`ollama pull ${requestedModel ?? "<model>"}\` or \`ace doctor --repair-ollama\`.`, res.status, text, {
+                    kind: "ollama_model_load_error",
+                    model: requestedModel,
+                    suggested_remediation: `run ollama pull ${requestedModel ?? "<model>"} or ace doctor --repair-ollama`,
+                });
+            }
+            lastError = new OllamaError(`Ollama API error: ${res.status} ${res.statusText}`, res.status, text);
+            if (res.status < 500 || attempt === maxAttempts) {
+                throw lastError;
+            }
+            await sleep(100 * attempt);
         }
-        return res;
+        throw lastError ?? new OllamaError("Ollama API request failed", 0, "");
     }
     /** Stream newline-delimited JSON from a ReadableStream */
     async *streamJsonLines(body) {
@@ -182,11 +217,17 @@ export class OllamaClient {
 export class OllamaError extends Error {
     statusCode;
     responseBody;
-    constructor(message, statusCode, responseBody) {
+    kind;
+    meta;
+    suggested_remediation;
+    constructor(message, statusCode, responseBody, options) {
         super(message);
         this.statusCode = statusCode;
         this.responseBody = responseBody;
         this.name = "OllamaError";
+        this.kind = options?.kind;
+        this.meta = options?.model ? { model: options.model } : undefined;
+        this.suggested_remediation = options?.suggested_remediation;
     }
 }
 //# sourceMappingURL=ollama.js.map

package/dist/tui/openai-compatible.d.ts

@@ -15,6 +15,7 @@ export interface OpenAICompatibleChatRequest {
     messages: OpenAICompatibleChatMessage[];
     temperature?: number;
     topP?: number;
+    onProviderEvent?: (event: OpenAICompatibleProviderEvent) => void;
 }
 export interface OpenAICompatibleChatChunk {
     text: string;
@@ -22,6 +23,18 @@ export interface OpenAICompatibleChatChunk {
     promptTokens?: number;
     completionTokens?: number;
 }
+export type OpenAICompatibleAdapterStage = "streaming_chat" | "non_streaming_chat" | "completions";
+export interface OpenAICompatibleProviderEvent {
+    provider: string;
+    stage: OpenAICompatibleAdapterStage;
+    event: "attempt" | "success" | "fallback" | "parse_error";
+    reason?: string;
+    statusCode?: number;
+    next_stage?: OpenAICompatibleAdapterStage;
+    fallback_count?: number;
+    sample_hex?: string;
+    sample_text?: string;
+}
 export interface ProviderConfigOverride {
     baseUrl?: string;
     apiKey?: string;