zames_pro 2.80.8 → 2.81.1

package/dist/glm-chats.js

@@ -0,0 +1,170 @@
+// PURE scraping/parsing helpers for the GLM provider (chat.z.ai).
+//
+// Mirrors qwen-chats.ts: the chat list and the restored dialogue are read from
+// a page we do not control, so the policy has ONE home that is unit-testable
+// WITHOUT Playwright. The scrapers run INSIDE page.evaluate, so they use only
+// their arguments and DOM globals.
+//
+// Live shapes (see test/fixtures/glm/):
+//   GET /api/v1/chats/?page=1  -> a BARE ARRAY of {id,title,updated_at,...}
+//   GET /api/v1/chats/<id>     -> {chat:{history:{messages:{<id>:{...}}}}}; the
+//                                 assistant node carries NO content (verified),
+//                                 so a restored dialogue is mostly the user's
+//                                 turns and the answers come from the DOM.
+//   a chat link                -> a[href="/c/<uuid>"]
+const CHAT_HREF_RE = /\/c\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i;
+/**
+ * In-page scraper for the sidebar chat list (fallback for when the API call
+ * fails). Returns ids/titles in document order, de-duplicated, capped at
+ * `limit`. The title element inside a z.ai row is not class-stable, so the
+ * row's textContent (collapsed) is used.
+ */
+export function scrapeGlmChatList(limit) {
+    const out = [];
+    const seen = new Set();
+    const anchors = document.querySelectorAll('a[href*="/c/"]');
+    for (const a of Array.from(anchors)) {
+        const href = a.getAttribute('href') || '';
+        const m = href.match(CHAT_HREF_RE);
+        if (!m)
+            continue;
+        if (seen.has(m[1]))
+            continue;
+        seen.add(m[1]);
+        const title = (a.textContent || '').trim().replace(/\s+/g, ' ');
+        out.push({ id: m[1], title });
+        if (out.length >= limit)
+            break;
+    }
+    return out;
+}
+/**
+ * In-page scraper for the WHOLE visible dialogue of the open chat. Nested
+ * duplicate containers are collapsed to the OUTERMOST one (the same real bug
+ * as Qwen: a broad selector matched both the wrapper and the inner block and
+ * every turn printed twice). Reasoning blocks are skipped by class.
+ */
+export function scrapeGlmChatMessages(opts) {
+    const thinkRe = new RegExp(opts.thinkRe, 'i');
+    const userRe = new RegExp(opts.userRe, 'i');
+    const inThink = (e) => {
+        let n = e;
+        while (n) {
+            if (thinkRe.test((n.className || '').toString()))
+                return true;
+            n = n.parentElement;
+        }
+        return false;
+    };
+    let containers = [];
+    for (const sel of opts.containerSels) {
+        const found = Array.from(document.querySelectorAll(sel)).filter((e) => !inThink(e) && (e.textContent || '').trim().length > 0);
+        if (found.length) {
+            containers = found;
+            break;
+        }
+    }
+    const uniq = Array.from(new Set(containers));
+    const blocks = uniq.filter((b) => !uniq.some((o) => o !== b && o.contains(b)));
+    const out = [];
+    for (const c of blocks) {
+        const role = userRe.test((c.className || '').toString())
+            ? 'user'
+            : 'assistant';
+        const text = (c.textContent || '').trim();
+        if (!text)
+            continue;
+        out.push({ role, text });
+    }
+    return out;
+}
+// ---------- API payload parsers (pure, unit-tested) ----------
+/**
+ * Parse `GET /api/v1/chats/?page=1`. The live shape is a BARE ARRAY; older /
+ * other builds wrap it in `{data:[...]}` or key it by id. Returns [] for
+ * anything unrecognizable (never throws).
+ */
+export function parseGlmChatList(json) {
+    let arr = json;
+    if (arr && typeof arr === 'object' && !Array.isArray(arr)) {
+        const o = arr;
+        // A wrapper key wins; otherwise the object itself is an id-keyed MAP
+        // of chats (a real alternative shape), not an empty list.
+        arr = o.data ?? o.chats ?? o.list ?? o.items ?? arr;
+    }
+    const keyed = Array.isArray(arr)
+        ? null
+        : arr && typeof arr === 'object'
+            ? Object.entries(arr)
+            : null;
+    if (!Array.isArray(arr) && !keyed)
+        return [];
+    const entries = Array.isArray(arr)
+        ? arr.map((c) => ['', c])
+        : keyed;
+    const out = [];
+    for (const [key, c] of entries) {
+        if (!c || typeof c !== 'object')
+            continue;
+        const m = c;
+        const raw = m.id ?? m.chat_id;
+        const id = typeof raw === 'string'
+            ? raw
+            : typeof raw === 'number' && Number.isFinite(raw)
+                ? String(raw)
+                : key;
+        if (!id)
+            continue;
+        const title = (typeof m.title === 'string' && m.title) ||
+            (typeof m.name === 'string' && m.name) ||
+            '';
+        out.push({ id, title: title.trim() });
+    }
+    return out;
+}
+/**
+ * Parse one chat's history from `GET /api/v1/chats/<id>`. The live shape is
+ * `{chat:{history:{messages:{<id>:{role,content,...}}}}}`; an array and a flat
+ * `messages` are accepted too. Assistant nodes carry NO content in the live
+ * response, so those turns are simply absent (the DOM is the fallback).
+ */
+export function parseGlmHistory(json) {
+    const root = json;
+    if (!root || typeof root !== 'object')
+        return [];
+    let messages = root.messages;
+    if (!messages && root.chat && typeof root.chat === 'object') {
+        const chat = root.chat;
+        if (chat.history && typeof chat.history === 'object') {
+            messages = chat.history.messages;
+        }
+        else if (chat.messages) {
+            messages = chat.messages;
+        }
+    }
+    const arr = Array.isArray(messages)
+        ? messages
+        : messages && typeof messages === 'object'
+            ? Object.values(messages)
+            : null;
+    if (!arr)
+        return [];
+    const sorted = arr
+        .filter((x) => !!x && typeof x === 'object')
+        .sort((a, b) => (Number(a.timestamp) || 0) - (Number(b.timestamp) || 0));
+    const out = [];
+    for (const m of sorted) {
+        const roleStr = String(m.role ?? '').toLowerCase();
+        const isUser = roleStr === 'user' || roleStr === 'human';
+        const role = isUser ? 'user' : 'assistant';
+        let text = '';
+        if (typeof m.content === 'string')
+            text = m.content;
+        else if (typeof m.text === 'string')
+            text = m.text;
+        text = text.trim();
+        if (text)
+            out.push({ role, text });
+    }
+    return out;
+}

package/dist/glm-flags.js

@@ -0,0 +1,75 @@
+// PURE inspection of z.ai's completion REQUEST body.
+//
+// WHY: GLM has no stable UI toggle for thinking / web search in the observed
+// build — the flags travel in the request body that the SITE builds:
+//   features.enable_thinking, features.web_search, features.auto_web_search,
+//   features.preview_mode, features.flags[]
+// (see test/fixtures/glm/completions-request.json — a real capture).
+//
+// Two of them MUST stay off, whatever the operator's thinking/search setting:
+//   - preview_mode / the `general_agent` flag turn on z.ai's OWN agent runtime,
+//     which emits its own tool calls and changes the answer format — that
+//     breaks the zames tool-call protocol;
+//   - image_generation likewise.
+// So the provider VERIFIES the body it just sent and warns the operator
+// instead of silently accepting a broken format.
+//
+// This module owns the knowledge; glm-browser.ts only wires it to the page.
+/** Read the features from a parsed completion body (tolerant of shapes). */
+export function readGlmBodyFeatures(body) {
+    const out = { flags: [] };
+    if (!body || typeof body !== 'object')
+        return out;
+    const b = body;
+    const f = b.features;
+    if (!f || typeof f !== 'object')
+        return out;
+    const feat = f;
+    if (typeof feat.enable_thinking === 'boolean') {
+        out.enableThinking = feat.enable_thinking;
+    }
+    if (typeof feat.web_search === 'boolean')
+        out.webSearch = feat.web_search;
+    if (typeof feat.auto_web_search === 'boolean') {
+        out.autoWebSearch = feat.auto_web_search;
+    }
+    if (typeof feat.preview_mode === 'boolean')
+        out.previewMode = feat.preview_mode;
+    if (typeof feat.image_generation === 'boolean') {
+        out.imageGeneration = feat.image_generation;
+    }
+    if (Array.isArray(feat.flags)) {
+        out.flags = feat.flags.filter((x) => typeof x === 'string');
+    }
+    return out;
+}
+/**
+ * PURE: the UNSAFE mode names that are ON in this body. An empty array means
+ * the body is safe for the zames tool-call protocol.
+ */
+export function unsafeGlmModes(feat) {
+    const bad = [];
+    if (feat.previewMode)
+        bad.push('preview_mode');
+    if (feat.imageGeneration)
+        bad.push('image_generation');
+    if (feat.flags.includes('general_agent'))
+        bad.push('general_agent');
+    return bad;
+}
+/**
+ * PURE: does the body match the operator's DESIRED thinking/search state?
+ * Used to report a mismatch (the site decides the final body, so a UI flip
+ * that did not take effect must be visible, not guessed).
+ */
+export function glmFlagsMismatch(feat, want) {
+    const out = [];
+    if (typeof feat.enableThinking === 'boolean') {
+        if (feat.enableThinking !== want.thinking)
+            out.push('thinking');
+    }
+    const ws = feat.webSearch === true || feat.autoWebSearch === true;
+    if (want.webSearch !== ws)
+        out.push('web_search');
+    return out;
+}

package/dist/glm-net-capture.js

@@ -0,0 +1,338 @@
+// Extraction of the RAW model answer from z.ai's (GLM) network data.
+//
+// The DOM distorts the answer (markdown/LaTeX/link auto-detection), so —
+// exactly like DeepSeek (net-capture.ts) and Qwen (qwen-net-capture.ts) — the
+// answer the agent consumes is parsed from the intercepted SSE stream.
+//
+// The live shape (verified against a signed-in session, see
+// test/fixtures/glm/answer-simple.sse):
+//
+//   data: {"type":"chat:completion","data":{"delta_content":"...","phase":"thinking"}}
+//   data: {"type":"chat:completion","data":{"phase":"other","usage":{prompt_tokens,...}}}
+//   data: {"type":"chat:completion","data":{"delta_content":"PONG","phase":"answer"}}
+//   data: {"type":"chat:completion","data":{"phase":"done","done":true}}
+//
+// Other phases observed in a real stream and what they mean for the agent:
+//   thinking      - the reasoning chain; NEVER part of the answer
+//   tool_call     - z.ai's OWN tool call (delta_name/delta_arguments); z.ai
+//                   runs it in its sandbox and sends back tool_response. This
+//                   is NOT the zames protocol - the agent must not see it as
+//                   an answer either, so the provider disables that runtime
+//                   (preview_mode/agent flags, see glm-ui.ts) and this parser
+//                   skips the phase.
+//   tool_response - the sandbox output of the step above
+//   answer        - the answer text (concatenated)
+//   done          - the terminal chunk
+//
+// `usage.prompt_tokens` is the closest thing z.ai exposes to "used context"
+// (there is no accumulated_token_usage like DeepSeek's).
+const NL = String.fromCharCode(10);
+function parseDataLines(body) {
+    const out = [];
+    for (const line of String(body || '').split(NL)) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('data:'))
+            continue;
+        const payload = trimmed.slice(5).trim();
+        if (!payload || payload === '[DONE]')
+            continue;
+        try {
+            const obj = JSON.parse(payload);
+            if (obj && typeof obj === 'object')
+                out.push(obj);
+        }
+        catch { }
+    }
+    return out;
+}
+/** The `data` object of a `chat:completion` chunk (the live envelope). */
+function completionData(obj) {
+    if (obj.type !== 'chat:completion')
+        return null;
+    const d = obj.data;
+    return d && typeof d === 'object' ? d : null;
+}
+/** True when the chunk belongs to a non-answer phase (reasoning/tools). */
+function isNonAnswerPhase(phase) {
+    if (typeof phase !== 'string')
+        return false;
+    return /think|tool|reason/i.test(phase);
+}
+/**
+ * Assemble the answer text from the GLM SSE stream. Only chunks whose phase
+ * is exactly `answer` contribute: the reasoning (`thinking`) and z.ai's own
+ * tool traffic (`tool_call` / `tool_response`) must never leak into the
+ * answer, or the agent would treat them as a command.
+ *
+ * An OpenAI-compatible `choices[].delta.content` shape is also accepted as a
+ * safety net (the same fallback Qwen's parser has).
+ */
+export function extractFromSse(body) {
+    let out = '';
+    for (const obj of parseDataLines(body)) {
+        const d = completionData(obj);
+        if (d) {
+            const phase = d.phase;
+            if (typeof phase === 'string' && phase !== 'answer')
+                continue;
+            const content = d.delta_content;
+            if (typeof content === 'string' && content)
+                out += content;
+            continue;
+        }
+        // OpenAI-compatible fallback.
+        const choices = obj.choices;
+        if (!Array.isArray(choices))
+            continue;
+        for (const ch of choices) {
+            if (!ch || typeof ch !== 'object')
+                continue;
+            const c = ch;
+            const delta = c.delta && typeof c.delta === 'object'
+                ? c.delta
+                : c.message && typeof c.message === 'object'
+                    ? c.message
+                    : null;
+            if (!delta)
+                continue;
+            if (isNonAnswerPhase(delta.phase))
+                continue;
+            if (typeof delta.content === 'string' && delta.content) {
+                out += delta.content;
+            }
+        }
+    }
+    return out;
+}
+/** A plain JSON body (a non-streamed response): pick the answer only. */
+export function extractFromJson(body) {
+    let obj;
+    try {
+        obj = JSON.parse(body);
+    }
+    catch {
+        return '';
+    }
+    return pickAnswer(obj);
+}
+function pickAnswer(node) {
+    if (node == null)
+        return '';
+    if (typeof node === 'string')
+        return node;
+    if (Array.isArray(node))
+        return node.map(pickAnswer).join('');
+    if (typeof node !== 'object')
+        return '';
+    const obj = node;
+    if (typeof obj.phase === 'string' && obj.phase !== 'answer') {
+        return '';
+    }
+    if (typeof obj.delta_content === 'string')
+        return obj.delta_content;
+    if (Array.isArray(obj.choices)) {
+        let out = '';
+        for (const ch of obj.choices) {
+            if (!ch || typeof ch !== 'object')
+                continue;
+            const c = ch;
+            const delta = c.delta && typeof c.delta === 'object'
+                ? c.delta
+                : c.message && typeof c.message === 'object'
+                    ? c.message
+                    : c;
+            if (isNonAnswerPhase(delta.phase))
+                continue;
+            const content = delta.content;
+            if (typeof content === 'string')
+                out += content;
+        }
+        if (out)
+            return out;
+    }
+    for (const key of ['content', 'text', 'answer']) {
+        const v = obj[key];
+        if (typeof v === 'string' && v)
+            return v;
+    }
+    return '';
+}
+/** A universal attempt: first SSE, then regular JSON. */
+export function extractAnswer(body) {
+    const sse = extractFromSse(body);
+    if (sse)
+        return sse;
+    return extractFromJson(body);
+}
+/**
+ * The CONTEXT size (tokens) from `usage.prompt_tokens` - the prompt size for
+ * the turn, the same idea as DeepSeek's accumulated_token_usage. Falls back to
+ * `total_tokens`. Null when the body carries no usage.
+ */
+export function extractTokenUsage(body) {
+    let lastPrompt = null;
+    let lastTotal = null;
+    for (const obj of parseDataLines(body)) {
+        const d = completionData(obj);
+        const usage = d ? d.usage : obj.usage;
+        if (!usage || typeof usage !== 'object')
+            continue;
+        const u = usage;
+        if (typeof u.prompt_tokens === 'number' && Number.isFinite(u.prompt_tokens))
+            lastPrompt = u.prompt_tokens;
+        if (typeof u.total_tokens === 'number' && Number.isFinite(u.total_tokens))
+            lastTotal = u.total_tokens;
+    }
+    if (lastPrompt !== null)
+        return lastPrompt;
+    if (lastTotal !== null)
+        return lastTotal;
+    try {
+        const obj = JSON.parse(body);
+        const usage = obj?.usage;
+        if (usage) {
+            if (typeof usage.prompt_tokens === 'number')
+                return usage.prompt_tokens;
+            if (typeof usage.total_tokens === 'number')
+                return usage.total_tokens;
+        }
+    }
+    catch { }
+    return null;
+}
+/** True when a chunk marks the end of the stream (`done: true`). */
+export function isDoneChunk(obj) {
+    const d = completionData(obj);
+    if (!d)
+        return false;
+    return d.done === true || d.phase === 'done';
+}
+/**
+ * True when the stream ENDED with no answer content - the model finished with
+ * only reasoning (or only z.ai's own tool traffic). The caller then retries
+ * instead of waiting out the whole timeout. Mirrors Qwen's
+ * isFinishedWithoutAnswer.
+ */
+export function isFinishedWithoutAnswer(body) {
+    const b = String(body || '');
+    if (!b)
+        return false;
+    let finished = false;
+    for (const obj of parseDataLines(b)) {
+        if (isDoneChunk(obj))
+            finished = true;
+    }
+    if (!finished)
+        return false;
+    return extractFromSse(b) === '';
+}
+/** True when the body carries actual answer text in a chunk. */
+function hasAnswerContent(body) {
+    for (const obj of parseDataLines(body)) {
+        const d = completionData(obj);
+        if (d && d.phase === 'answer') {
+            if (typeof d.delta_content === 'string' && d.delta_content.trim()) {
+                return true;
+            }
+        }
+        const choices = obj.choices;
+        if (!Array.isArray(choices))
+            continue;
+        for (const ch of choices) {
+            if (!ch || typeof ch !== 'object')
+                continue;
+            const c = ch;
+            const delta = c.delta;
+            if (!delta || isNonAnswerPhase(delta.phase))
+                continue;
+            if (typeof delta.content === 'string' && delta.content.trim())
+                return true;
+        }
+    }
+    return false;
+}
+// The classifiers below run against the RAW body, so a phrase like `please try
+// again later` would also match a NORMAL answer (the model explaining retry
+// logic) and make ask() back off on a good turn. A real notice arrives in an
+// ERROR payload (`type: "error"` / a code) or as a bare notice with NO answer
+// content; answer text lives in `phase: "answer"` chunks.
+const ERROR_PAYLOAD_RE = /"type"\s*:\s*"error"|"error"\s*:|\{\s*"code"\s*:/i;
+/** True when the RAW body is z.ai's rate-limit notice. */
+/**
+ * True when z.ai answers that the ACCOUNT quota is exhausted
+ * (`insufficient_quota`, HTTP 429). Distinct from a transient rate limit:
+ * it does not clear in minutes, so ask() must fail at once with a clear
+ * message instead of retrying for the whole budget.
+ */
+export function isQuotaExhaustedText(body) {
+    return /insufficient_quota|quota (?:exceeded|exhausted)|exceeded your current quota/i.test(String(body || ''));
+}
+export function isRateLimitText(body) {
+    const b = String(body || '');
+    if (!b)
+        return false;
+    if (/"code"\s*:\s*"(?:rate_limit|quota_limit)"/i.test(b))
+        return true;
+    if (!ERROR_PAYLOAD_RE.test(b) && hasAnswerContent(b))
+        return false;
+    // A generic "please try again later" belongs to the BUSY family; a rate
+    // limit has its own wording (or a code matched above).
+    return /too many requests|rate limit|too frequent|high demand|слишком часто/i.test(b);
+}
+/** True when the RAW body is a transient server-busy notice. */
+export function isServerBusyText(body) {
+    const b = String(body || '');
+    if (!b)
+        return false;
+    if (isRateLimitText(b))
+        return false;
+    if (!ERROR_PAYLOAD_RE.test(b) && hasAnswerContent(b))
+        return false;
+    return /server is busy|service unavailable|please try again later|high demand/i.test(b);
+}
+/**
+ * True when the site says the GUEST quota is over. It cannot be waited out
+ * (it needs a login), so ask() fails fast with a "sign in" message instead of
+ * burning the retry budget.
+ */
+export function isGuestLimitText(body) {
+    const b = String(body || '');
+    if (!b)
+        return false;
+    // A chat-create response contains the OLD guest email (`guest-123@guest.com`)
+    // and the word `guest` in the chat id/title. A SIGNED-IN session therefore
+    // looked like a guest limit (a real false positive: the operator was told
+    // "working as a guest" while the session was active). The notice must be an
+    // ERROR payload or an EXPLICIT limit sentence, never a bare `guest` word.
+    const explicit = /guest (?:chat |daily |usage )?limit|reached the guest|log ?in to continue|sign ?in to continue|гостевой лимит/i.test(b);
+    if (!explicit)
+        return false;
+    if (!ERROR_PAYLOAD_RE.test(b) && hasAnswerContent(b))
+        return false;
+    return true;
+}
+/**
+ * True when the raw body is z.ai's Aliyun captcha challenge. The site answers
+ * a POST with a "security verification" page instead of a stream, which the
+ * agent cannot solve - the operator must sign in in the browser window.
+ */
+export function isCaptchaText(body) {
+    const b = String(body || '');
+    if (!b)
+        return false;
+    return /security verification|drag the slider|CertifyId/i.test(b);
+}
+/**
+ * Read the chat id off the RAW body (the chat list / history JSON carries it as
+ * `id`, and an SSE chunk may echo `chat_id`).
+ */
+export function extractChatId(body) {
+    const b = String(body || '');
+    if (!b)
+        return null;
+    const m1 = b.match(/"chat_id"\s*:\s*"([0-9a-f-]{36})"/i);
+    if (m1)
+        return m1[1];
+    const m2 = b.match(/"id"\s*:\s*"([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})"/i);
+    return m2 ? m2[1] : null;
+}