teleton 0.8.5 → 0.8.6

package/dist/chunk-OMQIAWEU.js

@@ -0,0 +1,273 @@
+import {
+  hashText,
+  serializeEmbedding
+} from "./chunk-Z5WY7BSB.js";
+import {
+  KNOWLEDGE_CHUNK_SIZE
+} from "./chunk-J4WDJ7XS.js";
+
+// src/memory/agent/knowledge.ts
+import { readFileSync, existsSync, readdirSync, statSync } from "fs";
+import { join } from "path";
+var _instance = null;
+function setKnowledgeIndexer(indexer) {
+  _instance = indexer;
+}
+function getKnowledgeIndexer() {
+  return _instance;
+}
+var KnowledgeIndexer = class {
+  constructor(db, workspaceDir, embedder, vectorEnabled) {
+    this.db = db;
+    this.workspaceDir = workspaceDir;
+    this.embedder = embedder;
+    this.vectorEnabled = vectorEnabled;
+  }
+  getEmbedder() {
+    return this.embedder;
+  }
+  async indexAll(options) {
+    const files = this.listMemoryFiles();
+    let indexed = 0;
+    let skipped = 0;
+    for (const file of files) {
+      const wasIndexed = await this.indexFile(file, options?.force);
+      if (wasIndexed) {
+        indexed++;
+      } else {
+        skipped++;
+      }
+    }
+    return { indexed, skipped };
+  }
+  async indexFile(absPath, force) {
+    if (!existsSync(absPath) || !absPath.endsWith(".md")) {
+      return false;
+    }
+    const content = readFileSync(absPath, "utf-8");
+    const relPath = absPath.replace(this.workspaceDir + "/", "");
+    const fileHash = hashText(content);
+    if (!force) {
+      const existing = this.db.prepare(`SELECT hash FROM knowledge WHERE path = ? AND source = 'memory' LIMIT 1`).get(relPath);
+      if (existing?.hash === fileHash) {
+        return false;
+      }
+    }
+    const chunks = this.chunkMarkdown(content, relPath);
+    const texts = chunks.map((c) => c.text);
+    const embeddings = await this.embedder.embedBatch(texts);
+    const chunksToInsert = [];
+    const idsToSupersede = [];
+    if (this.vectorEnabled) {
+      const vecQuery = this.db.prepare(`
+        SELECT kv.id, kv.distance
+        FROM (
+          SELECT id, distance
+          FROM knowledge_vec
+          WHERE embedding MATCH ? AND k = 5
+        ) kv
+        JOIN knowledge k ON k.id = kv.id
+        WHERE k.path != ? AND (k.status = 'active' OR k.status IS NULL)
+        ORDER BY kv.distance
+      `);
+      for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        const embedding = embeddings[i] ?? [];
+        if (embedding.length === 0) {
+          chunksToInsert.push({ chunk, embedding });
+          continue;
+        }
+        let skip = false;
+        try {
+          const similar = vecQuery.all(serializeEmbedding(embedding), relPath);
+          const exactDup = similar.find((r) => r.distance < 0.1);
+          if (exactDup) {
+            skip = true;
+          } else {
+            const nearDup = similar.find((r) => r.distance < 0.15);
+            if (nearDup) {
+              idsToSupersede.push(nearDup.id);
+            }
+          }
+        } catch {
+        }
+        if (!skip) {
+          chunksToInsert.push({ chunk, embedding });
+        }
+      }
+    } else {
+      for (let i = 0; i < chunks.length; i++) {
+        chunksToInsert.push({ chunk: chunks[i], embedding: embeddings[i] ?? [] });
+      }
+    }
+    this.db.transaction(() => {
+      if (this.vectorEnabled) {
+        this.db.prepare(
+          `DELETE FROM knowledge_vec WHERE id IN (
+              SELECT id FROM knowledge WHERE path = ? AND source = 'memory'
+            )`
+        ).run(relPath);
+      }
+      this.db.prepare(`DELETE FROM knowledge WHERE path = ? AND source = 'memory'`).run(relPath);
+      if (idsToSupersede.length > 0) {
+        const placeholders = idsToSupersede.map(() => "?").join(", ");
+        this.db.prepare(
+          `UPDATE knowledge SET status = 'superseded', updated_at = unixepoch() WHERE id IN (${placeholders})`
+        ).run(...idsToSupersede);
+      }
+      const insert = this.db.prepare(`
+        INSERT INTO knowledge (id, source, path, text, embedding, start_line, end_line, hash, status, memory_type)
+        VALUES (?, 'memory', ?, ?, ?, ?, ?, ?, 'active', ?)
+      `);
+      const insertVec = this.vectorEnabled ? this.db.prepare(`INSERT INTO knowledge_vec (id, embedding) VALUES (?, ?)`) : null;
+      const memoryType = this.getMemoryType(relPath);
+      for (const { chunk, embedding } of chunksToInsert) {
+        insert.run(
+          chunk.id,
+          chunk.path,
+          chunk.text,
+          serializeEmbedding(embedding),
+          chunk.startLine,
+          chunk.endLine,
+          fileHash,
+          memoryType
+        );
+        if (insertVec && embedding.length > 0) {
+          insertVec.run(chunk.id, serializeEmbedding(embedding));
+        }
+      }
+    })();
+    return true;
+  }
+  async pruneOrphans() {
+    const paths = this.db.prepare(
+      `SELECT DISTINCT path FROM knowledge WHERE path IS NOT NULL AND source = 'memory'
+         AND (status = 'active' OR status IS NULL)`
+    ).all();
+    let markedInactive = 0;
+    const orphanedPaths = [];
+    for (const { path } of paths) {
+      const absPath = join(this.workspaceDir, path);
+      const archivedPath = join(
+        this.workspaceDir,
+        "memory",
+        "archived",
+        path.replace(/^memory\//, "")
+      );
+      if (!existsSync(absPath) && !existsSync(archivedPath)) {
+        orphanedPaths.push(path);
+      }
+    }
+    if (orphanedPaths.length > 0) {
+      const ph = orphanedPaths.map(() => "?").join(", ");
+      const result = this.db.prepare(
+        `UPDATE knowledge SET status = 'inactive', updated_at = unixepoch()
+           WHERE path IN (${ph}) AND source = 'memory'`
+      ).run(...orphanedPaths);
+      markedInactive = result.changes;
+    }
+    const staleIds = this.db.prepare(
+      `SELECT id FROM knowledge WHERE status = 'inactive' AND updated_at < unixepoch() - ?`
+    ).all(30 * 86400);
+    let deleted = 0;
+    if (staleIds.length > 0) {
+      const ids = staleIds.map((r) => r.id);
+      const placeholders = ids.map(() => "?").join(", ");
+      this.db.transaction(() => {
+        if (this.vectorEnabled) {
+          this.db.prepare(`DELETE FROM knowledge_vec WHERE id IN (${placeholders})`).run(...ids);
+        }
+        this.db.prepare(`DELETE FROM knowledge WHERE id IN (${placeholders})`).run(...ids);
+      })();
+      deleted = ids.length;
+    }
+    return { markedInactive, deleted };
+  }
+  listMemoryFiles() {
+    const files = [];
+    const memoryMd = join(this.workspaceDir, "MEMORY.md");
+    if (existsSync(memoryMd)) {
+      files.push(memoryMd);
+    }
+    const memoryDir = join(this.workspaceDir, "memory");
+    if (existsSync(memoryDir)) {
+      const entries = readdirSync(memoryDir);
+      for (const entry of entries) {
+        const absPath = join(memoryDir, entry);
+        if (statSync(absPath).isFile() && entry.endsWith(".md")) {
+          files.push(absPath);
+        }
+      }
+    }
+    return files;
+  }
+  getMemoryType(relPath) {
+    if (relPath === "MEMORY.md") return "procedural";
+    if (/^memory\/(\d{4}-\d{2}-\d{2}|consolidated-)/.test(relPath)) return "episodic";
+    return "semantic";
+  }
+  /**
+   * Chunk markdown content with structure awareness.
+   * Respects heading boundaries, code blocks, and list groups.
+   * Target: KNOWLEDGE_CHUNK_SIZE chars, hard max: 2x target.
+   */
+  chunkMarkdown(content, path) {
+    const lines = content.split("\n");
+    const chunks = [];
+    const targetSize = KNOWLEDGE_CHUNK_SIZE;
+    const hardMax = targetSize * 2;
+    let currentChunk = "";
+    let startLine = 1;
+    let currentLine = 1;
+    let inCodeBlock = false;
+    let overlapPrefix = "";
+    const flushChunk = () => {
+      const text = currentChunk.trim();
+      if (text.length > 0) {
+        chunks.push({
+          id: hashText(`${path}:${startLine}:${currentLine - 1}`),
+          source: "memory",
+          path,
+          text,
+          startLine,
+          endLine: currentLine - 1,
+          hash: hashText(text)
+        });
+        const nonEmpty = text.split("\n").filter((l) => l.trim());
+        overlapPrefix = nonEmpty.length > 0 ? nonEmpty.slice(-2).join("\n") + "\n" : "";
+      }
+      currentChunk = overlapPrefix;
+      startLine = currentLine;
+    };
+    for (const line of lines) {
+      if (line.trimStart().startsWith("```")) {
+        inCodeBlock = !inCodeBlock;
+      }
+      if (!inCodeBlock && currentChunk.length >= targetSize) {
+        const isHeading = /^#{1,6}\s/.test(line);
+        const isBlankLine = line.trim() === "";
+        const isHorizontalRule = /^(-{3,}|\*{3,}|_{3,})\s*$/.test(line.trim());
+        if (isHeading) {
+          flushChunk();
+        } else if ((isBlankLine || isHorizontalRule) && currentChunk.length >= targetSize) {
+          currentChunk += line + "\n";
+          currentLine++;
+          flushChunk();
+          continue;
+        } else if (currentChunk.length >= hardMax) {
+          flushChunk();
+        }
+      }
+      currentChunk += line + "\n";
+      currentLine++;
+    }
+    flushChunk();
+    return chunks;
+  }
+};
+
+export {
+  setKnowledgeIndexer,
+  getKnowledgeIndexer,
+  KnowledgeIndexer
+};

package/dist/chunk-PCT7GYBP.js

@@ -0,0 +1,274 @@
+import {
+  ALLOWED_EXTENSIONS,
+  WORKSPACE_PATHS,
+  WORKSPACE_ROOT
+} from "./chunk-L653KKCR.js";
+import {
+  createLogger
+} from "./chunk-V3S3NXBQ.js";
+
+// src/memory/daily-logs.ts
+import { existsSync as existsSync2, mkdirSync, appendFileSync, readFileSync, readdirSync as readdirSync2, unlinkSync } from "fs";
+import { join } from "path";
+
+// src/workspace/validator.ts
+import { existsSync, lstatSync, readdirSync } from "fs";
+import { resolve, normalize, relative, extname, basename } from "path";
+import { homedir } from "os";
+var WorkspaceSecurityError = class extends Error {
+  constructor(message, attemptedPath) {
+    super(message);
+    this.attemptedPath = attemptedPath;
+    this.name = "WorkspaceSecurityError";
+  }
+};
+function decodeRecursive(str) {
+  let decoded = str;
+  let prev = "";
+  let iterations = 0;
+  const maxIterations = 10;
+  while (decoded !== prev && iterations < maxIterations) {
+    prev = decoded;
+    try {
+      decoded = decodeURIComponent(decoded);
+    } catch {
+      break;
+    }
+    iterations++;
+  }
+  return decoded;
+}
+function validatePath(inputPath, allowCreate = false) {
+  if (!inputPath || inputPath.trim() === "") {
+    throw new WorkspaceSecurityError("Path cannot be empty.", inputPath);
+  }
+  const trimmedPath = inputPath.trim().replace(/\\/g, "/");
+  const decodedPath = decodeRecursive(trimmedPath);
+  let absolutePath;
+  if (decodedPath.startsWith("/")) {
+    absolutePath = resolve(normalize(decodedPath));
+  } else if (decodedPath.startsWith("~/")) {
+    const expanded = decodedPath.replace(/^~(?=$|[\\/])/, homedir());
+    absolutePath = resolve(expanded);
+  } else {
+    absolutePath = resolve(WORKSPACE_ROOT, normalize(decodedPath));
+  }
+  const relativePath = relative(WORKSPACE_ROOT, absolutePath);
+  if (relativePath.startsWith("..") || relativePath.startsWith("/")) {
+    throw new WorkspaceSecurityError(
+      `Access denied: Path '${inputPath}' is outside the workspace. Only files in ~/.teleton/workspace/ are accessible.`,
+      inputPath
+    );
+  }
+  const exists = existsSync(absolutePath);
+  if (!exists && !allowCreate) {
+    throw new WorkspaceSecurityError(
+      `File not found: '${inputPath}' does not exist in workspace.`,
+      inputPath
+    );
+  }
+  if (exists) {
+    const stats = lstatSync(absolutePath);
+    if (stats.isSymbolicLink()) {
+      throw new WorkspaceSecurityError(
+        `Access denied: Symbolic links are not allowed for security reasons.`,
+        inputPath
+      );
+    }
+  }
+  return {
+    absolutePath,
+    relativePath,
+    exists,
+    isDirectory: exists ? lstatSync(absolutePath).isDirectory() : false,
+    extension: extname(absolutePath).toLowerCase(),
+    filename: basename(absolutePath)
+  };
+}
+function validateReadPath(inputPath) {
+  const validated = validatePath(inputPath, false);
+  if (validated.isDirectory) {
+    throw new WorkspaceSecurityError(`Cannot read directory as file: '${inputPath}'`, inputPath);
+  }
+  return validated;
+}
+var IMMUTABLE_FILES = ["SOUL.md", "STRATEGY.md", "SECURITY.md"];
+function validateWritePath(inputPath, fileType) {
+  const validated = validatePath(inputPath, true);
+  if (IMMUTABLE_FILES.includes(validated.filename)) {
+    throw new WorkspaceSecurityError(
+      `Cannot write to ${validated.filename}. This file is configured by the owner. Use memory_write instead.`,
+      inputPath
+    );
+  }
+  if (fileType && ALLOWED_EXTENSIONS[fileType]) {
+    const allowedExts = ALLOWED_EXTENSIONS[fileType];
+    if (!allowedExts.includes(validated.extension)) {
+      throw new WorkspaceSecurityError(
+        `Invalid file type: '${validated.extension}' is not allowed for ${fileType}. Allowed: ${allowedExts.join(", ")}`,
+        inputPath
+      );
+    }
+  }
+  return validated;
+}
+function validateDirectory(inputPath) {
+  const validated = validatePath(inputPath, true);
+  if (validated.exists && !validated.isDirectory) {
+    throw new WorkspaceSecurityError(
+      `Path exists but is not a directory: '${inputPath}'`,
+      inputPath
+    );
+  }
+  return validated;
+}
+
+// src/memory/daily-logs.ts
+var log = createLogger("Memory");
+var MEMORY_DIR = WORKSPACE_PATHS.MEMORY_DIR;
+function formatDate(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function getDailyLogPath(date = /* @__PURE__ */ new Date()) {
+  return join(MEMORY_DIR, `${formatDate(date)}.md`);
+}
+function ensureMemoryDir() {
+  if (!existsSync2(MEMORY_DIR)) {
+    mkdirSync(MEMORY_DIR, { recursive: true });
+  }
+}
+function appendToDailyLog(content, date = /* @__PURE__ */ new Date()) {
+  try {
+    ensureMemoryDir();
+    const logPath = getDailyLogPath(date);
+    const timestamp = date.toLocaleTimeString("en-US", { hour12: false });
+    if (!existsSync2(logPath)) {
+      const header = `# Daily Log - ${formatDate(date)}
+
+`;
+      appendFileSync(logPath, header, { encoding: "utf-8", mode: 384 });
+    }
+    const entry = `## ${timestamp}
+
+${content}
+
+---
+
+`;
+    appendFileSync(logPath, entry, "utf-8");
+    log.info(`Daily log updated: ${logPath}`);
+  } catch (error) {
+    log.error({ err: error }, "Failed to write daily log");
+  }
+}
+function readDailyLog(date = /* @__PURE__ */ new Date()) {
+  try {
+    const logPath = getDailyLogPath(date);
+    if (!existsSync2(logPath)) return null;
+    return readFileSync(logPath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+var DAILY_LOG_LINE_LIMIT = 100;
+function truncateDailyLog(content) {
+  const lines = content.split("\n");
+  if (lines.length <= DAILY_LOG_LINE_LIMIT) return content;
+  const truncated = lines.slice(-DAILY_LOG_LINE_LIMIT).join("\n");
+  const dropped = lines.length - DAILY_LOG_LINE_LIMIT;
+  return `_[... ${dropped} earlier lines omitted]_
+
+${truncated}`;
+}
+function readRecentMemory() {
+  const today = /* @__PURE__ */ new Date();
+  const yesterday = new Date(today);
+  yesterday.setDate(yesterday.getDate() - 1);
+  const parts = [];
+  const yesterdayLog = readDailyLog(yesterday);
+  if (yesterdayLog) {
+    parts.push(`## Yesterday (${formatDate(yesterday)})
+
+${truncateDailyLog(yesterdayLog)}`);
+  }
+  const todayLog = readDailyLog(today);
+  if (todayLog) {
+    parts.push(`## Today (${formatDate(today)})
+
+${truncateDailyLog(todayLog)}`);
+  }
+  if (parts.length === 0) {
+    return null;
+  }
+  return `# Recent Memory
+
+${parts.join("\n\n---\n\n")}`;
+}
+function writeSessionEndSummary(summary, reason) {
+  const content = `### Session End (${reason})
+
+${summary}`;
+  appendToDailyLog(content);
+}
+function writeSummaryToDailyLog(summary) {
+  appendToDailyLog(`### Memory Flush (Pre-Compaction)
+
+${summary}`);
+}
+function cleanupOldDailyLogs(maxAgeDays = 60) {
+  if (!existsSync2(MEMORY_DIR)) return 0;
+  const cutoffMs = Date.now() - maxAgeDays * 864e5;
+  const datePattern = /^(\d{4}-\d{2}-\d{2})\.md$/;
+  let deleted = 0;
+  try {
+    const files = readdirSync2(MEMORY_DIR);
+    for (const file of files) {
+      const match = datePattern.exec(file);
+      if (!match) continue;
+      const fileDate = new Date(match[1]).getTime();
+      if (Number.isNaN(fileDate)) continue;
+      if (fileDate < cutoffMs) {
+        try {
+          unlinkSync(join(MEMORY_DIR, file));
+          deleted++;
+        } catch (innerError) {
+          log.warn({ err: innerError, file }, "Failed to delete old daily log");
+        }
+      }
+    }
+  } catch (error) {
+    log.error({ err: error }, "Failed to list memory directory for cleanup");
+  }
+  if (deleted > 0) {
+    log.info(`Cleaned up ${deleted} daily log file(s) older than ${maxAgeDays} days`);
+  }
+  return deleted;
+}
+function writeConversationMilestone(chatId, topic, details) {
+  const content = `### Conversation Milestone
+
+**Chat**: ${chatId}
+**Topic**: ${topic}
+
+${details}`;
+  appendToDailyLog(content);
+}
+
+export {
+  WorkspaceSecurityError,
+  validatePath,
+  validateReadPath,
+  validateWritePath,
+  validateDirectory,
+  getDailyLogPath,
+  appendToDailyLog,
+  readDailyLog,
+  readRecentMemory,
+  writeSessionEndSummary,
+  writeSummaryToDailyLog,
+  cleanupOldDailyLogs,
+  writeConversationMilestone
+};

package/dist/{chunk-35X3V6OW.js → chunk-QYZBWU2D.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-L653KKCR.js";
 import {
   createLogger
-} from "./chunk-NQ6FZKCE.js";
+} from "./chunk-V3S3NXBQ.js";
 
 // src/utils/module-db.ts
 import Database from "better-sqlite3";
@@ -115,13 +115,13 @@ function migrateFromMainDb(moduleDb, tables) {
         );
         totalMigrated += src.c;
         log.info(`Migrated ${src.c} rows from memory.db \u2192 ${table}`);
-      } catch (e) {
-        log.warn({ err: e }, `Could not migrate table ${table}`);
+      } catch (innerError) {
+        log.warn({ err: innerError }, `Could not migrate table ${table}`);
       }
     }
     moduleDb.exec(`DETACH DATABASE main_db`);
-  } catch (e) {
-    log.warn({ err: e }, `Migration from memory.db failed`);
+  } catch (error) {
+    log.warn({ err: error }, `Migration from memory.db failed`);
     try {
       moduleDb.exec(`DETACH DATABASE main_db`);
     } catch {

package/dist/{chunk-WTDAICGT.js → chunk-R6W4DJRK.js}

@@ -1,6 +1,6 @@
 import {
   createLogger
-} from "./chunk-NQ6FZKCE.js";
+} from "./chunk-V3S3NXBQ.js";
 
 // src/providers/claude-code-credentials.ts
 import { readFileSync, writeFileSync, existsSync } from "fs";
@@ -26,8 +26,8 @@ function readCredentialsFile() {
   try {
     const raw = readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
-  } catch (e) {
-    log.warn({ err: e, path: filePath }, "Failed to parse Claude Code credentials file");
+  } catch (error) {
+    log.warn({ err: error, path: filePath }, "Failed to parse Claude Code credentials file");
     return null;
   }
 }
@@ -122,16 +122,16 @@ async function performOAuthRefresh(refreshToken) {
         }
       };
       writeFileSync(filePath, JSON.stringify(updated, null, 2), { mode: 384 });
-    } catch (e) {
-      log.warn({ err: e }, "Failed to persist refreshed OAuth credentials to disk");
+    } catch (innerError) {
+      log.warn({ err: innerError }, "Failed to persist refreshed OAuth credentials to disk");
     }
     cachedToken = data.access_token;
     cachedExpiresAt = newExpiresAt;
     cachedRefreshToken = newRefreshToken;
     log.info("Claude Code OAuth token refreshed successfully");
     return cachedToken;
-  } catch (e) {
-    log.warn({ err: e }, "OAuth token refresh request failed");
+  } catch (error) {
+    log.warn({ err: error }, "OAuth token refresh request failed");
     return null;
   }
 }

package/dist/{chunk-5SEMA47R.js → chunk-RILOEIK6.js}

@@ -1,6 +1,6 @@
 import {
   createLogger
-} from "./chunk-NQ6FZKCE.js";
+} from "./chunk-V3S3NXBQ.js";
 
 // src/api/tls.ts
 import { existsSync, readFileSync, writeFileSync } from "fs";

package/dist/{chunk-6OOHHJ4N.js → chunk-TFTNZZDH.js}

@@ -1,23 +1,35 @@
 // src/config/providers.ts
 var PROVIDER_REGISTRY = {
-  anthropic: {
-    id: "anthropic",
-    displayName: "Anthropic (Claude)",
+  "claude-code": {
+    id: "claude-code",
+    displayName: "Claude Code (Auto)",
     envVar: "ANTHROPIC_API_KEY",
     keyPrefix: "sk-ant-",
-    keyHint: "sk-ant-api03-...",
+    keyHint: "Auto-detected from Claude Code",
     consoleUrl: "https://console.anthropic.com/",
     defaultModel: "claude-opus-4-6",
     utilityModel: "claude-haiku-4-5-20251001",
     toolLimit: null,
     piAiProvider: "anthropic"
   },
-  "claude-code": {
-    id: "claude-code",
-    displayName: "Claude Code (Auto)",
+  zai: {
+    id: "zai",
+    displayName: "ZAI (Zhipu)",
+    envVar: "ZAI_API_KEY",
+    keyPrefix: null,
+    keyHint: "...",
+    consoleUrl: "https://z.ai/manage-apikey/apikey-list",
+    defaultModel: "glm-4.7-flash",
+    utilityModel: "glm-4.5-flash",
+    toolLimit: 128,
+    piAiProvider: "zai"
+  },
+  anthropic: {
+    id: "anthropic",
+    displayName: "Anthropic (Claude)",
     envVar: "ANTHROPIC_API_KEY",
     keyPrefix: "sk-ant-",
-    keyHint: "Auto-detected from Claude Code",
+    keyHint: "sk-ant-api03-...",
     consoleUrl: "https://console.anthropic.com/",
     defaultModel: "claude-opus-4-6",
     utilityModel: "claude-haiku-4-5-20251001",
@@ -120,18 +132,6 @@ var PROVIDER_REGISTRY = {
     toolLimit: 128,
     piAiProvider: "cerebras"
   },
-  zai: {
-    id: "zai",
-    displayName: "ZAI (Zhipu)",
-    envVar: "ZAI_API_KEY",
-    keyPrefix: null,
-    keyHint: "...",
-    consoleUrl: "https://z.ai/manage-apikey/apikey-list",
-    defaultModel: "glm-4.7",
-    utilityModel: "glm-4.7-flash",
-    toolLimit: 128,
-    piAiProvider: "zai"
-  },
   minimax: {
     id: "minimax",
     displayName: "MiniMax",