@modelworks/quack 0.2.8 → 0.2.9

package/dist/bin.js

@@ -247,7 +247,7 @@ async function cmdCircuitAdd(url) {
     }
 }
 async function cmdCircuitRemove(ref) {
-    const result = await removeCircuit(ref);
+    const result = await removeCircuit(ref, effectiveApiBase());
     console.log(`Removed circuit '${result.name}' (${result.circuit_uid}).`);
     // Clear default_circuit if it pointed to the removed circuit.
     const config = readConfig();
@@ -404,6 +404,19 @@ async function cmdAgentDescribe(name) {
         console.log(`Default:     yes`);
     }
 }
+async function cmdAgentSet(name) {
+    const agent = getAgent(name);
+    if (!agent) {
+        console.error(`Unknown agent: ${name}`);
+        console.error("Run `quack agent list` to see available agents.");
+        process.exit(1);
+    }
+    requireQuackProject();
+    const config = readConfig();
+    config.default_agent = name;
+    writeConfig(config);
+    console.log(`Default agent set to ${GREEN}${name}${RESET}.`);
+}
 // ---------------------------------------------------------------------------
 // Interactive picker
 // ---------------------------------------------------------------------------
@@ -713,6 +726,12 @@ function buildCli() {
         .action(async (name) => {
         await cmdAgentDescribe(name);
     });
+    agent
+        .command("set <name>")
+        .description("Set the default agent (written to .quack/config.json)")
+        .action(async (name) => {
+        await cmdAgentSet(name);
+    });
     // auth group
     const auth = program
         .command("auth")

package/dist/build-info.json

@@ -1,8 +1,8 @@
 {
-    "version": "0.2.8",
-    "build": "20261025131502",
-    "commit": "afaf6a2",
-    "commitLong": "afaf6a2cd8edc9c225df99eb55daa81944de4761",
+    "version": "0.2.9",
+    "build": "20261027101714",
+    "commit": "a1daf81",
+    "commitLong": "a1daf819f41569ed710ee0697ec56db7ab370339",
     "dirty": false,
-    "builtAt": "2026-10-25T13:15:02.360Z"
+    "builtAt": "2026-10-27T10:17:14.504Z"
 }

package/dist/circuit.d.ts

@@ -25,6 +25,7 @@ export declare function fromApiAdapterType(apiType: string): string;
  * Accepts:
  * - `https://modelworks.ai/circuits/<circuit_uid>`
  * - `https://modelworks.ai/circuits/<circuit_uid>/versions/<version_uid>`
+ * - `https://modelworks.ai/<username>/<circuitName>` (slug-based URL)
  * - `<circuit_uid>` or `c-xxx`
  * - `<version_uid>` or `cv-xxx`
  */
@@ -99,7 +100,7 @@ export declare function addCircuit(input: string, apiBase: string): Promise<AddR
  * Public adaptors are NOT deleted — they belong to the circuit (system-created),
  * not to the quack user. Other users of the same circuit rely on them.
  */
-export declare function removeCircuit(input: string): Promise<{
+export declare function removeCircuit(input: string, apiBase: string): Promise<{
     circuit_uid: string;
     name: string;
 }>;

package/dist/circuit.js

@@ -59,16 +59,17 @@ export function fromApiAdapterType(apiType) {
  * Accepts:
  * - `https://modelworks.ai/circuits/<circuit_uid>`
  * - `https://modelworks.ai/circuits/<circuit_uid>/versions/<version_uid>`
+ * - `https://modelworks.ai/<username>/<circuitName>` (slug-based URL)
  * - `<circuit_uid>` or `c-xxx`
  * - `<version_uid>` or `cv-xxx`
  */
 export function parseCircuitRef(input) {
     // Bare UIDs first.
     if (input.startsWith("cv-")) {
-        return { circuit_uid: "", version_uid: input };
+        return { circuit_uid: "", version_uid: input, slug: null };
     }
     if (input.startsWith("c-")) {
-        return { circuit_uid: input, version_uid: null };
+        return { circuit_uid: input, version_uid: null, slug: null };
     }
     // URLs.
     try {
@@ -76,16 +77,21 @@ export function parseCircuitRef(input) {
         const parts = url.pathname.split("/").filter(Boolean);
         // Expected: ["circuits", "<circuit_uid>"] or ["circuits", "<circuit_uid>", "versions", "<version_uid>"]
         const circuitsIdx = parts.indexOf("circuits");
-        if (circuitsIdx === -1 || circuitsIdx + 1 >= parts.length) {
-            throw new Error(`Could not find circuit UID in URL: ${input}`);
+        if (circuitsIdx !== -1 && circuitsIdx + 1 < parts.length) {
+            const circuit_uid = parts[circuitsIdx + 1];
+            let version_uid = null;
+            const versionsIdx = parts.indexOf("versions", circuitsIdx);
+            if (versionsIdx !== -1 && versionsIdx + 1 < parts.length) {
+                version_uid = parts[versionsIdx + 1];
+            }
+            return { circuit_uid, version_uid, slug: null };
         }
-        const circuit_uid = parts[circuitsIdx + 1];
-        let version_uid = null;
-        const versionsIdx = parts.indexOf("versions", circuitsIdx);
-        if (versionsIdx !== -1 && versionsIdx + 1 < parts.length) {
-            version_uid = parts[versionsIdx + 1];
+        // Slug-based URL: ["<username>", "<circuitName>"]
+        if (parts.length === 2) {
+            const slug = `${parts[0]}/${parts[1]}`;
+            return { circuit_uid: "", version_uid: null, slug };
         }
-        return { circuit_uid, version_uid };
+        throw new Error(`Could not find circuit UID in URL: ${input}`);
     }
     catch (err) {
         throw new Error(`Invalid circuit reference: ${input}. Use a circuit URL, c-xxx, or cv-xxx. (${err.message})`);
@@ -156,6 +162,16 @@ export async function getUsername(apiBase, userUid) {
     const payload = await parseJson(res);
     return unwrap(payload).username ?? "unknown";
 }
+/** Resolve a slug (`"username/circuitName"`) to a circuit UID via the API. */
+async function resolveSlug(apiBase, slug) {
+    const res = await authedFetch(apiBase, `/api/slug/${slug}`);
+    const data = unwrap(await parseJson(res));
+    if (data.entity_type !== "circuit") {
+        throw new Error(`'${slug}' resolved to a ${data.entity_type}, not a circuit. ` +
+            `Use a circuit URL, c-xxx, or cv-xxx.`);
+    }
+    return data.entity_uid;
+}
 /**
  * Resolve a circuit reference to a RUNNING version.
  *
@@ -165,6 +181,11 @@ export async function getUsername(apiBase, userUid) {
  */
 export async function resolveRunningVersion(apiBase, ref) {
     let circuitUid = ref.circuit_uid;
+    // Slug-based URL (e.g. https://modelworks.ai/openscale/deepseek-v41-flash):
+    // resolve the slug to a circuit UID via the API before proceeding.
+    if (!circuitUid && ref.slug) {
+        circuitUid = await resolveSlug(apiBase, ref.slug);
+    }
     // If only a version UID was given, fetch the version first to discover
     // its parent circuit UID.
     if (!circuitUid && ref.version_uid) {
@@ -327,11 +348,25 @@ export async function addCircuit(input, apiBase) {
  * Public adaptors are NOT deleted — they belong to the circuit (system-created),
  * not to the quack user. Other users of the same circuit rely on them.
  */
-export async function removeCircuit(input) {
+export async function removeCircuit(input, apiBase) {
     const ref = parseCircuitRef(input);
-    const circuitUid = ref.circuit_uid;
-    // Find the circuit name from config.
+    let circuitUid = ref.circuit_uid;
     const config = readConfig();
+    // For slug-based URLs, try matching by the stored `url` first (no API call).
+    // If that fails, resolve the slug via the API to get the circuit UID.
+    if (ref.slug && !circuitUid) {
+        const byUrl = config.circuits.find((c) => c.url === input);
+        if (byUrl) {
+            circuitUid = byUrl.circuit_uid;
+        }
+        else {
+            circuitUid = await resolveSlug(apiBase, ref.slug);
+        }
+    }
+    if (!circuitUid) {
+        throw new Error("Could not resolve circuit UID from the given reference.");
+    }
+    // Find the circuit name from config.
     const entry = config.circuits.find((c) => c.circuit_uid === circuitUid);
     if (!entry) {
         throw new Error(`Circuit ${circuitUid} is not in this project.`);

package/dist/install.js

@@ -266,6 +266,10 @@ async function main() {
         fs.mkdirSync(binDir, { recursive: true });
         fs.rmSync(distDir, { recursive: true, force: true });
         copyDir(sourceDist, distDir);
+        // Write a minimal package.json so Node treats dist/ as ESM.
+        // (The source package.json with "type": "module" is at the tarball
+        // root, not inside dist/, so it doesn't get copied.)
+        fs.writeFileSync(path.join(distDir, "package.json"), JSON.stringify({ type: "module" }, null, 2) + "\n");
         spinner.succeed(`Installed to ${installDir}`);
     }
     catch (err) {

package/dist/proxy.js

@@ -25,9 +25,9 @@ export function startProxy(opts) {
                     opts.onDebug(line);
             };
             // TCP-level connection log — fires for EVERY request, even before
-            // HTTP parsing. This tells us if the request reached the proxy at all.
+            // HTTP parsing.
             if (opts.onDebug) {
-                opts.onDebug(`[tcp] connection: ${req.method} ${req.url} from ${req.socket.remoteAddress}:${req.socket.remotePort}`);
+                opts.onDebug(`[tcp] ${new Date().toISOString()} ${req.method} ${req.url} from ${req.socket.remoteAddress}:${req.socket.remotePort}`);
             }
             try {
                 const targetUrl = new URL(req.url ?? "/", opts.apiBase);
@@ -41,8 +41,45 @@ export function startProxy(opts) {
                 const chunks = [];
                 for await (const chunk of req)
                     chunks.push(chunk);
-                const body = chunks.length > 0 ? Buffer.concat(chunks) : null;
+                let body = chunks.length > 0 ? Buffer.concat(chunks) : null;
                 debug(`body read: ${body ? body.length + " bytes" : "(empty)"}`);
+                // Strip output token limits from circuit adaptor query requests.
+                //
+                // OpenCode's openai-compatible provider sends a low default output
+                // token limit (~100-128). Reasoning models like DeepSeek V4.1 Flash
+                // spend this budget on reasoning before producing content, resulting
+                // in empty responses. Stripping lets the circuit's own default_value
+                // (e.g. 128000) apply instead.
+                //
+                // Different SDKs use different field names for the same concept:
+                // - OpenAI Chat Completions API: max_tokens / max_completion_tokens
+                // - AI SDK: maxOutputTokens
+                const isAdaptorQuery = req.method === "POST" &&
+                    /\/api\/circuit-adaptors\/[^/]+\/query/.test(req.url ?? "");
+                if (isAdaptorQuery && body) {
+                    try {
+                        const parsed = JSON.parse(body.toString("utf8"));
+                        let stripped = false;
+                        for (const key of [
+                            "max_tokens",
+                            "max_completion_tokens",
+                            "max_output_tokens",
+                            "maxOutputTokens",
+                        ]) {
+                            if (key in parsed) {
+                                delete parsed[key];
+                                stripped = true;
+                            }
+                        }
+                        if (stripped) {
+                            body = Buffer.from(JSON.stringify(parsed), "utf8");
+                            debug(`stripped output token limit from request body`);
+                        }
+                    }
+                    catch {
+                        // Not JSON or malformed — forward as-is.
+                    }
+                }
                 // Build forwarded headers — strip client auth + host, inject our own.
                 const headers = {};
                 for (const [key, value] of Object.entries(req.headers)) {
@@ -53,6 +90,9 @@ export function startProxy(opts) {
                 }
                 headers.authorization = `Bearer ${opts.getAccessToken()}`;
                 headers.host = targetUrl.host;
+                // Update content-length if we modified the body.
+                if (body !== null)
+                    headers["content-length"] = String(body.length);
                 if (opts.onDebug) {
                     debug(`--- request headers (incoming) ---`);
                     for (const [k, v] of Object.entries(req.headers)) {
@@ -88,6 +128,17 @@ export function startProxy(opts) {
                 // Forward response status + headers.
                 res.statusCode = upstream.status;
                 for (const [key, value] of upstream.headers) {
+                    // Rewrite content-type for circuit adaptor SSE responses.
+                    // The API returns `application/stream+json` but OpenCode's
+                    // openai-compatible provider expects `text/event-stream` to
+                    // parse SSE chunks. Without this, the provider doesn't
+                    // recognize the stream and the response appears empty.
+                    if (key.toLowerCase() === "content-type" &&
+                        isAdaptorQuery &&
+                        value.includes("application/stream+json")) {
+                        res.setHeader(key, "text/event-stream; charset=utf-8");
+                        continue;
+                    }
                     res.setHeader(key, value);
                 }
                 // Capture the circuit run UID for history saving.

package/dist/types.d.ts

@@ -114,10 +114,16 @@ export interface QuackState {
 }
 /**
  * Parsed circuit URL or bare UID.
+ *
+ * For slug-based URLs (`/{username}/{circuitName}`), `slug` is set and
+ * `circuit_uid` is empty — the caller must resolve the slug to a circuit
+ * UID via the API (`GET /api/slug/{slug}`).
  */
 export interface ParsedCircuitRef {
     circuit_uid: string;
     version_uid: string | null;
+    /** `"username/circuitName"` for slug-based URLs, null for UID-based refs. */
+    slug: string | null;
 }
 /**
  * A circuit version record as returned by the ModelWorks API

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelworks/quack",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "Launch AI coding agents (OpenCode, and more) with ModelWorks circuits as model providers. OAuth login, local proxy with auth injection, run history, and git-like project config.",
   "type": "module",
   "bin": {