@neta-art/cohub-cli 9.1.1 → 10.0.0

package/dist/runtime/model-catalog.js

@@ -1,19 +1,65 @@
 import { record } from "./json-rpc.js";
-/** Codex's built-in catalog is not authoritative for an arbitrary custom provider. */
+const thinkingLevels = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+const thinkingLevel = (value) => thinkingLevels.includes(value) ? value : undefined;
+/**
+ * Publish only picker metadata, never provider credentials or request configuration.
+ * `state` is a fresh Pi's `get_state`: its model is what Pi runs when Cohub requests
+ * nothing, and its level is resolved and clamped for that model only. Pi's levels for
+ * other models live in its settings, which RPC does not expose; those models fall back
+ * to the picker's rule, and Cohub always sends the chosen level explicitly.
+ */
+export function piModelCatalog(entries, state) {
+    const current = record(state.model);
+    const currentLevel = thinkingLevel(state.thinkingLevel);
+    return entries.flatMap((value) => {
+        const model = record(value);
+        if (typeof model.id !== "string" || !model.id || typeof model.provider !== "string" || !model.provider)
+            return [];
+        const map = record(model.thinkingLevelMap);
+        const thinkingLevelMap = Object.fromEntries(thinkingLevels.flatMap((level) => map[level] === null || typeof map[level] === "string" ? [[level, map[level]]] : []));
+        const isDefault = current.provider === model.provider && current.id === model.id;
+        return [{
+                harness: "pi", id: model.id, provider: model.provider, name: typeof model.name === "string" ? model.name : model.id,
+                ...(isDefault ? { isDefault } : {}),
+                ...(typeof model.reasoning === "boolean" ? { reasoning: model.reasoning } : {}),
+                ...(isDefault && currentLevel ? { defaultThinkingLevel: currentLevel } : {}),
+                ...(Object.keys(thinkingLevelMap).length ? { thinkingLevelMap } : {}),
+            }];
+    });
+}
+function codexThinking(model, configuredEffort) {
+    if (!Array.isArray(model.supportedReasoningEfforts))
+        return {};
+    const efforts = new Set(model.supportedReasoningEfforts.map((entry) => record(entry).reasoningEffort));
+    const thinkingLevelMap = Object.fromEntries(thinkingLevels.map((level) => {
+        const effort = level === "off" ? "none" : level;
+        return [level, efforts.has(effort) ? effort : null];
+    }));
+    const normalize = (value) => thinkingLevel(value === "none" ? "off" : value);
+    const configured = normalize(configuredEffort);
+    const fallback = normalize(model.defaultReasoningEffort);
+    const defaultThinkingLevel = [configured, fallback].find((level) => level && thinkingLevelMap[level] != null);
+    return {
+        reasoning: thinkingLevels.some((level) => level !== "off" && thinkingLevelMap[level] != null),
+        thinkingLevelMap,
+        ...(defaultThinkingLevel ? { defaultThinkingLevel } : {}),
+    };
+}
+/** Use Codex's picker-visible model/list for every provider, including custom providers. */
 export function codexModelCatalog(configResponse, entries) {
     const config = record(configResponse.config);
     const provider = typeof config.model_provider === "string" ? config.model_provider : "openai";
     const configuredModel = typeof config.model === "string" ? config.model : null;
-    const customCatalog = typeof config.model_catalog_json === "string";
-    const catalog = provider !== "openai" && !customCatalog ? [] : entries;
-    const models = catalog.flatMap((value) => {
+    const models = entries.flatMap((value) => {
         const model = record(value);
         const id = typeof model.model === "string" ? model.model : typeof model.id === "string" ? model.id : null;
         if (!id || model.hidden)
             return [];
-        return [{ harness: "codex", provider, id, name: typeof model.displayName === "string" ? model.displayName : id }];
+        // A configured model replaces the catalog's own default.
+        const isDefault = configuredModel ? id === configuredModel : model.isDefault === true;
+        return [{ harness: "codex", provider, id, name: typeof model.displayName === "string" ? model.displayName : id, ...(isDefault ? { isDefault } : {}), ...codexThinking(model, config.model_reasoning_effort) }];
     });
     if (configuredModel && !models.some((model) => model.id === configuredModel))
-        models.unshift({ harness: "codex", provider, id: configuredModel, name: configuredModel });
+        models.unshift({ harness: "codex", provider, id: configuredModel, name: configuredModel, isDefault: true });
     return models;
 }

package/dist/runtime/native/execution.js

@@ -294,7 +294,7 @@ async function runCodex(executor, turn, context) {
                     escalation = setTimeout(() => void host?.close().catch(() => undefined), ABORT_ESCALATION_MS);
             };
             signal.addEventListener("abort", abort, { once: true });
-            codex.request("turn/start", { threadId, clientUserMessageId: input.turnId, input: content, ...(input.thinkingLevel ? { effort: input.thinkingLevel } : {}) })
+            codex.request("turn/start", { threadId, clientUserMessageId: input.turnId, input: content, ...(input.thinkingLevel ? { effort: input.thinkingLevel === "off" ? "none" : input.thinkingLevel } : {}) })
                 .then((result) => { nativeTurnId ??= text(record(result.turn).id) || null; if (signal.aborted)
                 interrupt(); })
                 .catch(finish);

package/dist/safe-remote-image.d.ts

@@ -25,4 +25,8 @@ export declare function downloadPublicImage(input: string, options?: RemoteImage
     bytes: Uint8Array;
     mimeType: string;
 }>;
+export declare function downloadPublicAudio(input: string, options?: RemoteImageDownloadOptions): Promise<{
+    bytes: Uint8Array;
+    mimeType: string;
+}>;
 export {};

package/dist/safe-remote-image.js

@@ -13,6 +13,11 @@ const IMAGE_MIME_TYPES = new Set([
     "image/png",
     "image/webp",
 ]);
+const AUDIO_MIME_TYPES = new Set([
+    "audio/mpeg", "audio/mp3", "audio/mp4", "audio/aac", "audio/ogg",
+    "audio/wav", "audio/x-wav", "audio/wave", "audio/flac", "audio/x-flac",
+    "audio/webm", "audio/opus", "application/ogg",
+]);
 const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
 async function defaultLookup(hostname) {
     const records = await dns.lookup(hostname, { all: true, verbatim: true });
@@ -48,7 +53,7 @@ function requestPinned(url, addresses, timeoutMs, maxBytes) {
         const client = url.protocol === "https:" ? https : http;
         const request = client.request(url, {
             agent: false,
-            headers: { Accept: "image/avif,image/webp,image/png,image/jpeg,image/gif" },
+            headers: { Accept: "image/*,audio/*,application/ogg" },
             lookup: pinnedLookup(addresses),
         }, (response) => {
             const status = response.statusCode ?? 0;
@@ -61,7 +66,7 @@ function requestPinned(url, addresses, timeoutMs, maxBytes) {
             const declaredLength = Number(headers.get("content-length") ?? 0);
             if (Number.isFinite(declaredLength) && declaredLength > maxBytes) {
                 response.destroy();
-                reject(new Error(`Image exceeds the ${maxBytes} byte download limit`));
+                reject(new Error(`Media exceeds the ${maxBytes} byte download limit`));
                 return;
             }
             const chunks = [];
@@ -69,7 +74,7 @@ function requestPinned(url, addresses, timeoutMs, maxBytes) {
             response.on("data", (chunk) => {
                 total += chunk.byteLength;
                 if (total > maxBytes) {
-                    response.destroy(new Error(`Image exceeds the ${maxBytes} byte download limit`));
+                    response.destroy(new Error(`Media exceeds the ${maxBytes} byte download limit`));
                     return;
                 }
                 chunks.push(chunk);
@@ -86,7 +91,7 @@ function requestPinned(url, addresses, timeoutMs, maxBytes) {
             });
         });
         request.setTimeout(timeoutMs, () => {
-            request.destroy(new Error(`Image download timed out after ${timeoutMs}ms`));
+            request.destroy(new Error(`Media download timed out after ${timeoutMs}ms`));
         });
         request.once("error", reject);
         request.end();
@@ -95,7 +100,7 @@ function requestPinned(url, addresses, timeoutMs, maxBytes) {
 function remainingMs(deadline) {
     const remaining = deadline - Date.now();
     if (remaining <= 0)
-        throw new Error("Image download timed out");
+        throw new Error("Media download timed out");
     return remaining;
 }
 async function withDeadline(promise, deadline) {
@@ -105,7 +110,7 @@ async function withDeadline(promise, deadline) {
         return await Promise.race([
             promise,
             new Promise((_, reject) => {
-                timer = setTimeout(() => reject(new Error(`Image download timed out after ${timeoutMs}ms`)), timeoutMs);
+                timer = setTimeout(() => reject(new Error(`Media download timed out after ${timeoutMs}ms`)), timeoutMs);
             }),
         ]);
     }
@@ -117,7 +122,7 @@ async function withDeadline(promise, deadline) {
 async function resolvePublicUrl(value, lookup, deadline) {
     const normalized = normalizeBoardRemoteUrl(value);
     if (!normalized)
-        throw new Error("Image URL must be a public HTTP(S) URL");
+        throw new Error("Media URL must be a public HTTP(S) URL");
     const url = new URL(normalized);
     const hostname = url.hostname.replace(/^\[|\]$/g, "");
     const addresses = isIP(hostname)
@@ -126,11 +131,21 @@ async function resolvePublicUrl(value, lookup, deadline) {
     const [first, ...rest] = addresses;
     if (!first ||
         addresses.some((entry) => !isPublicBoardRemoteAddress(entry.address))) {
-        throw new Error("Image URL resolves to a private address");
+        throw new Error("Media URL resolves to a private address");
     }
     return { url, addresses: [first, ...rest] };
 }
-export async function downloadPublicImage(input, options = {}) {
+export function downloadPublicImage(input, options = {}) {
+    return downloadPublicMedia(input, IMAGE_MIME_TYPES, options);
+}
+export function downloadPublicAudio(input, options = {}) {
+    return downloadPublicMedia(input, AUDIO_MIME_TYPES, {
+        maxBytes: 64 * 1024 * 1024,
+        timeoutMs: 30_000,
+        ...options,
+    });
+}
+async function downloadPublicMedia(input, mimeTypes, options) {
     const lookup = options.lookup ?? defaultLookup;
     const requester = options.requester ?? requestPinned;
     const maxBytes = options.maxBytes ?? REMOTE_IMAGE_MAX_BYTES;
@@ -142,9 +157,9 @@ export async function downloadPublicImage(input, options = {}) {
         if (REDIRECT_STATUSES.has(response.status)) {
             const location = response.headers.get("location");
             if (!location)
-                throw new Error("Image redirect is missing a location");
+                throw new Error("Media redirect is missing a location");
             if (redirect === MAX_REDIRECTS)
-                throw new Error("Too many image redirects");
+                throw new Error("Too many media redirects");
             current = new URL(location, url).toString();
             continue;
         }
@@ -152,17 +167,17 @@ export async function downloadPublicImage(input, options = {}) {
             throw new Error(`HTTP ${response.status}`);
         }
         if (response.bytes.byteLength > maxBytes) {
-            throw new Error(`Image exceeds the ${maxBytes} byte download limit`);
+            throw new Error(`Media exceeds the ${maxBytes} byte download limit`);
         }
         const mimeType = response.headers
             .get("content-type")
             ?.split(";", 1)[0]
             ?.trim()
             .toLowerCase();
-        if (!mimeType || !IMAGE_MIME_TYPES.has(mimeType)) {
-            throw new Error("Remote background must be a supported raster image");
+        if (!mimeType || !mimeTypes.has(mimeType)) {
+            throw new Error("Remote resource has an unsupported media type");
         }
         return { bytes: response.bytes, mimeType };
     }
-    throw new Error("Too many image redirects");
+    throw new Error("Too many media redirects");
 }

package/dist/session-status.d.ts

@@ -0,0 +1,6 @@
+import type { SessionRecord } from "@neta-art/cohub";
+import type { Column } from "./output.js";
+type SessionStatusFields = Pick<SessionRecord, "activeTurn" | "lastTurnIssue">;
+export declare function sessionStatusText(session: Partial<SessionStatusFields>): string;
+export declare const SESSION_STATUS_COLUMN: Column;
+export {};

package/dist/session-status.js

@@ -0,0 +1,14 @@
+export function sessionStatusText(session) {
+    const turn = session.activeTurn;
+    if (turn)
+        return turn.status === "abort_requested" ? "stopping" : turn.status;
+    const issue = session.lastTurnIssue;
+    if (issue?.status === "failed")
+        return "failed";
+    return issue?.reason === "stale_active_recovered" ? "interrupted" : "";
+}
+export const SESSION_STATUS_COLUMN = {
+    key: "activeTurn",
+    label: "Status",
+    format: (_value, row) => sessionStatusText(row),
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "9.1.1",
+  "version": "10.0.0",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {
@@ -18,8 +18,8 @@
     "NOTICE"
   ],
   "dependencies": {
-    "@neta-art/cohub": "9.0.1",
-    "@neta-art/generation": "^0.1.30",
+    "@neta-art/cohub": "11.0.0",
+    "@neta-art/generation": "^0.1.33",
     "commander": "^15.0.0",
     "sharp": "^0.35.4",
     "ws": "^8.21.3"