claude-glm 1.0.1 → 1.1.0

package/README.md

@@ -58,7 +58,7 @@ That's it!
 ## Features
 
 - 🚀 **Easy switching** between GLM and Claude models
-- ⚡ **Multiple GLM models**: GLM-4.7 (latest), GLM-4.5, and GLM-4.5-Air (fast)
+- ⚡ **Multiple GLM models**: GLM-5 (latest), GLM-4.7, GLM-4.5, and GLM-4.5-Air (fast)
 - 🔒 **No sudo/admin required**: Installs to user's home directory
 - 🖥️ **Cross-platform**: Works on Windows, macOS, and Linux
 - 📁 **Isolated configs**: Each model uses its own config directory — no conflicts!
@@ -144,9 +144,9 @@ The installer creates these commands and aliases:
 The `ccx` command starts a local proxy that lets you switch between multiple AI providers in a single session:
 
 - **OpenAI**: GPT-4o, GPT-4o-mini, and more
-- **OpenRouter**: Access to hundreds of models
+- **OpenRouter**: Access to hundreds of models (including GLM-5)
 - **Google Gemini**: Gemini 1.5 Pro and Flash
-- **Z.AI GLM**: GLM-4.7, GLM-4.5, GLM-4.5-Air
+- **Z.AI GLM**: GLM-5, GLM-4.7, GLM-4.5, GLM-4.5-Air
 - **Anthropic**: Claude 3.5 Sonnet, etc.
 
 Switch models mid-session using `/model <provider>:<model-name>`. Perfect for comparing responses or using the right model for each task!
@@ -375,6 +375,8 @@ Use Claude Code's built-in `/model` command with provider prefixes:
 | `/model glm`    | `glm:glm-4.7`                          | Friendly GLM shortcut            |
 | `/model glm47`  | `glm:glm-4.7`                          | Explicit version                 |
 | `/model glm45`  | `glm:glm-4.5`                          | Previous version                 |
+| `/model glm5`   | `glm:glm-5`                             | Latest GLM-5 model              |
+| `/model glm5or`  | `openrouter:z-ai/glm-5`                 | GLM-5 via OpenRouter           |
 | `/model flash`  | `glm:glm-4-flash`                      | Fast model                       |
 | `/model opus`   | `anthropic:claude-opus-4-5-20251101`   | Claude Opus (API key required)   |
 | `/model sonnet` | `anthropic:claude-sonnet-4-5-20250929` | Claude Sonnet (API key required) |
@@ -389,6 +391,8 @@ Use Claude Code's built-in `/model` command with provider prefixes:
 ```typescript
 const MODEL_SHORTCUTS: Record<string, string> = {
   g: "glm:glm-4.7",
+  glm5: "glm:glm-5",
+  glm5or: "openrouter:z-ai/glm-5",
   o1: "openai:o1-preview", // Add your own!
   fast: "glm:glm-4-flash",
   // ... more shortcuts
@@ -745,7 +749,8 @@ Then reload: `. $PROFILE`
 **A**:
 
 - Use **`ccx`** for: Maximum flexibility, model comparison, leveraging different model strengths
-- Use **`ccg` (GLM-4.7)** for: Latest model, complex coding, refactoring, detailed explanations
+- Use **`/model glm5`** for: Latest GLM-5 with advanced agentic capabilities and long-horizon workflows
+- Use **`ccg` (GLM-4.7)** for: Complex coding, refactoring, detailed explanations
 - Use **`ccg45` (GLM-4.5)** for: Previous version, if you need consistency with older projects
 - Use **`ccf` (GLM-4.5-Air)** for: Quick questions, simple tasks, faster responses
 - Use **`cc` (Claude)** for: Your regular Anthropic Claude setup

package/adapters/map.ts

@@ -1,20 +1,33 @@
 // Provider parsing and message mapping utilities
-import { AnthropicMessage, AnthropicRequest, ProviderKey, ProviderModel } from "./types.js";
+import {
+  AnthropicMessage,
+  AnthropicRequest,
+  ProviderKey,
+  ProviderModel,
+} from "./types.js";
 
-const PROVIDER_PREFIXES: ProviderKey[] = ["openai", "openrouter", "gemini", "glm", "anthropic"];
+const PROVIDER_PREFIXES: ProviderKey[] = [
+  "openai",
+  "openrouter",
+  "gemini",
+  "glm",
+  "anthropic",
+];
 
 // Model shortcuts - add your own aliases here
 const MODEL_SHORTCUTS: Record<string, string> = {
   // GLM shortcuts
-  "g": "glm:glm-4.7",
-  "glm": "glm:glm-4.7",
-  "glm47": "glm:glm-4.7",
-  "glm45": "glm:glm-4.5",
-  "flash": "glm:glm-4-flash",
+  g: "glm:glm-4.7",
+  glm: "glm:glm-4.7",
+  glm47: "glm:glm-4.7",
+  glm45: "glm:glm-4.5",
+  glm5: "glm:glm-5",
+  glm5or: "openrouter:z-ai/glm-5",
+  flash: "glm:glm-4-flash",
   // Claude shortcuts (for API users)
-  "opus": "anthropic:claude-opus-4-5-20251101",
-  "sonnet": "anthropic:claude-sonnet-4-5-20250929",
-  "haiku": "anthropic:claude-haiku-4-5-20251001",
+  opus: "anthropic:claude-opus-4-5-20251101",
+  sonnet: "anthropic:claude-sonnet-4-5-20250929",
+  haiku: "anthropic:claude-haiku-4-5-20251001",
   // Add more shortcuts as needed
 };
 
@@ -23,7 +36,10 @@ const MODEL_SHORTCUTS: Record<string, string> = {
  * Supports formats: "provider:model" or "provider/model"
  * Falls back to defaults if no valid prefix found
  */
-export function parseProviderModel(modelField: string, defaults?: ProviderModel): ProviderModel {
+export function parseProviderModel(
+  modelField: string,
+  defaults?: ProviderModel,
+): ProviderModel {
   if (!modelField) {
     if (defaults) return defaults;
     throw new Error("Missing 'model' in request");
@@ -37,7 +53,11 @@ export function parseProviderModel(modelField: string, defaults?: ProviderModel)
     return { provider: "anthropic", model: expanded };
   }
 
-  const sep = expanded.includes(":") ? ":" : expanded.includes("/") ? "/" : null;
+  const sep = expanded.includes(":")
+    ? ":"
+    : expanded.includes("/")
+      ? "/"
+      : null;
   if (!sep) {
     // no prefix: fall back to defaults or assume glm as legacy
     return defaults ?? { provider: "glm", model: expanded };
@@ -57,11 +77,16 @@ export function parseProviderModel(modelField: string, defaults?: ProviderModel)
 /**
  * Warn if tools are being used with providers that may not support them
  */
-export function warnIfTools(req: AnthropicRequest, provider: ProviderKey): void {
+export function warnIfTools(
+  req: AnthropicRequest,
+  provider: ProviderKey,
+): void {
   if (req.tools && req.tools.length > 0) {
     // Only GLM and Anthropic support tools natively
     if (provider !== "glm" && provider !== "anthropic") {
-      console.warn(`[proxy] Warning: ${provider} may not fully support Anthropic-style tools. Passing through anyway.`);
+      console.warn(
+        `[proxy] Warning: ${provider} may not fully support Anthropic-style tools. Passing through anyway.`,
+      );
     }
   }
 }
@@ -91,7 +116,7 @@ export function toPlainText(content: AnthropicMessage["content"]): string {
 export function toOpenAIMessages(messages: AnthropicMessage[]) {
   return messages.map((m) => ({
     role: m.role,
-    content: toPlainText(m.content)
+    content: toPlainText(m.content),
   }));
 }
 
@@ -101,6 +126,6 @@ export function toOpenAIMessages(messages: AnthropicMessage[]) {
 export function toGeminiContents(messages: AnthropicMessage[]) {
   return messages.map((m) => ({
     role: m.role === "assistant" ? "model" : "user",
-    parts: [{ text: toPlainText(m.content) }]
+    parts: [{ text: toPlainText(m.content) }],
   }));
 }

package/adapters/providers/gemini.ts

@@ -71,6 +71,7 @@ export async function chatGemini(
   }
 
   stopAnthropicMessage(res);
+  res.raw.end();
 }
 
 function withStatus(status: number, message: string) {

package/adapters/providers/openai.ts

@@ -72,6 +72,7 @@ export async function chatOpenAI(
   }
 
   stopAnthropicMessage(res);
+  res.raw.end();
 }
 
 function withStatus(status: number, message: string) {

package/adapters/providers/openrouter.ts

@@ -1,12 +1,86 @@
-// OpenRouter adapter (OpenAI-compatible API)
+// OpenRouter adapter (OpenAI-compatible API) with full tool calling support
 import { FastifyReply } from "fastify";
 import { createParser } from "eventsource-parser";
-import { deltaText, startAnthropicMessage, stopAnthropicMessage } from "../sse.js";
-import { toOpenAIMessages } from "../map.js";
-import type { AnthropicRequest } from "../types.js";
+import { sendEvent } from "../sse.js";
+import type { AnthropicRequest, AnthropicMessage, AnthropicTool, AnthropicContentBlock } from "../types.js";
 
 const OR_BASE = process.env.OPENROUTER_BASE_URL || "https://openrouter.ai/api/v1";
 
+// ── Format converters: Anthropic → OpenAI ──────────────────────────────
+
+/** Convert Anthropic tools to OpenAI tools format */
+function toOpenAITools(tools: AnthropicTool[]) {
+  return tools.map((t) => ({
+    type: "function" as const,
+    function: {
+      name: t.name,
+      description: t.description ?? "",
+      parameters: t.input_schema ?? { type: "object", properties: {} },
+    },
+  }));
+}
+
+/** Convert Anthropic messages (with tool_use/tool_result) to OpenAI messages */
+function toOpenAIMessagesWithTools(messages: AnthropicMessage[]) {
+  const out: any[] = [];
+
+  for (const m of messages) {
+    if (typeof m.content === "string") {
+      out.push({ role: m.role, content: m.content });
+      continue;
+    }
+
+    // Complex content blocks - need to split into separate messages
+    const textParts: string[] = [];
+    const toolCalls: any[] = [];
+    const toolResults: any[] = [];
+
+    for (const block of m.content as AnthropicContentBlock[]) {
+      if (block.type === "text") {
+        textParts.push(block.text);
+      } else if (block.type === "tool_use") {
+        toolCalls.push({
+          id: block.id,
+          type: "function",
+          function: {
+            name: block.name,
+            arguments: typeof block.input === "string" ? block.input : JSON.stringify(block.input),
+          },
+        });
+      } else if (block.type === "tool_result") {
+        const content = typeof block.content === "string"
+          ? block.content
+          : JSON.stringify(block.content);
+        toolResults.push({
+          role: "tool",
+          tool_call_id: block.tool_use_id,
+          content,
+        });
+      }
+    }
+
+    // Assistant message with tool calls
+    if (m.role === "assistant" && toolCalls.length > 0) {
+      out.push({
+        role: "assistant",
+        content: textParts.join("") || null,
+        tool_calls: toolCalls,
+      });
+    } else if (textParts.length > 0) {
+      out.push({ role: m.role, content: textParts.join("") });
+    }
+
+    // Tool results become separate "tool" role messages
+    for (const tr of toolResults) {
+      out.push(tr);
+    }
+  }
+
+  return out;
+}
+
+// ── Main adapter ────────────────────────────────────────────────────────
+
 export async function chatOpenRouter(
   res: FastifyReply,
   body: AnthropicRequest,
@@ -20,10 +94,9 @@ export async function chatOpenRouter(
   const url = `${OR_BASE}/chat/completions`;
   const headers: Record<string, string> = {
     Authorization: `Bearer ${apiKey}`,
-    "Content-Type": "application/json"
+    "Content-Type": "application/json",
   };
 
-  // Add optional OpenRouter headers
   if (process.env.OPENROUTER_REFERER) {
     headers["HTTP-Referer"] = process.env.OPENROUTER_REFERER;
   }
@@ -31,24 +104,34 @@ export async function chatOpenRouter(
     headers["X-Title"] = process.env.OPENROUTER_TITLE;
   }
 
+  // Build OpenAI-format request
+  const hasTools = body.tools && body.tools.length > 0;
+  const messages = hasTools
+    ? toOpenAIMessagesWithTools(body.messages)
+    : toOpenAIMessagesWithTools(body.messages);
+
+  // Add system message if present
+  if (body.system) {
+    messages.unshift({ role: "system", content: body.system });
+  }
+
   const reqBody: any = {
     model,
-    messages: toOpenAIMessages(body.messages),
+    messages,
     stream: true,
     temperature: body.temperature ?? 0.7,
-    max_tokens: body.max_tokens
+    max_tokens: body.max_tokens,
   };
 
-  // Pass through tools if provided
-  if (body.tools && body.tools.length > 0) {
-    console.warn("[openrouter] Tools passed through but format may not be compatible");
-    reqBody.tools = body.tools;
+  if (hasTools) {
+    reqBody.tools = toOpenAITools(body.tools!);
+    console.log(`[openrouter] Sending ${body.tools!.length} tools (converted to OpenAI format)`);
   }
 
   const resp = await fetch(url, {
     method: "POST",
     headers,
-    body: JSON.stringify(reqBody)
+    body: JSON.stringify(reqBody),
   });
 
   if (!resp.ok || !resp.body) {
@@ -56,7 +139,83 @@ export async function chatOpenRouter(
     throw withStatus(resp.status || 500, `OpenRouter error: ${text}`);
   }
 
-  startAnthropicMessage(res, model);
+  // ── Stream response and convert back to Anthropic SSE format ──────
+
+  const msgId = `msg_${Date.now()}`;
+  let contentIndex = 0;
+  let hasStartedMessage = false;
+  let hasStartedThinking = false;
+  let hasStartedContent = false;
+
+  // Accumulate tool calls from streaming chunks
+  const pendingToolCalls: Record<number, { id: string; name: string; arguments: string }> = {};
+
+  function ensureMessageStarted() {
+    if (!hasStartedMessage) {
+      hasStartedMessage = true;
+      sendEvent(res, "message_start", {
+        type: "message_start",
+        message: {
+          id: msgId,
+          type: "message",
+          role: "assistant",
+          model,
+          content: [],
+          stop_reason: null,
+          stop_sequence: null,
+          usage: { input_tokens: 0, output_tokens: 0 },
+        },
+      });
+    }
+  }
+
+  function ensureThinkingBlockStarted() {
+    if (!hasStartedThinking) {
+      hasStartedThinking = true;
+      ensureMessageStarted();
+      sendEvent(res, "content_block_start", {
+        type: "content_block_start",
+        index: contentIndex,
+        content_block: { type: "thinking", thinking: "" },
+      });
+    }
+  }
+
+  function closeThinkingBlock() {
+    if (hasStartedThinking) {
+      sendEvent(res, "content_block_stop", {
+        type: "content_block_stop",
+        index: contentIndex,
+      });
+      contentIndex++;
+      hasStartedThinking = false;
+    }
+  }
+
+  function ensureContentBlockStarted() {
+    if (!hasStartedContent) {
+      // Close thinking block first if open
+      closeThinkingBlock();
+      hasStartedContent = true;
+      ensureMessageStarted();
+      sendEvent(res, "content_block_start", {
+        type: "content_block_start",
+        index: contentIndex,
+        content_block: { type: "text", text: "" },
+      });
+    }
+  }
+
+  function closeContentBlock() {
+    if (hasStartedContent) {
+      sendEvent(res, "content_block_stop", {
+        type: "content_block_stop",
+        index: contentIndex,
+      });
+      contentIndex++;
+      hasStartedContent = false;
+    }
+  }
 
   const reader = resp.body.getReader();
   const decoder = new TextDecoder();
@@ -66,8 +225,46 @@ export async function chatOpenRouter(
     if (!data || data === "[DONE]") return;
     try {
       const json = JSON.parse(data);
-      const chunk = json.choices?.[0]?.delta?.content ?? "";
-      if (chunk) deltaText(res, chunk);
+      const choice = json.choices?.[0];
+      if (!choice) return;
+
+      const delta = choice.delta;
+      if (!delta) return;
+
+      // Handle reasoning/thinking tokens (GLM-5 and other reasoning models)
+      const reasoningChunk = delta.reasoning || "";
+      if (reasoningChunk) {
+        ensureThinkingBlockStarted();
+        sendEvent(res, "content_block_delta", {
+          type: "content_block_delta",
+          index: contentIndex,
+          delta: { type: "thinking_delta", thinking: reasoningChunk },
+        });
+      }
+
+      // Handle text content
+      const textChunk = delta.content || "";
+      if (textChunk) {
+        ensureContentBlockStarted();
+        sendEvent(res, "content_block_delta", {
+          type: "content_block_delta",
+          index: contentIndex,
+          delta: { type: "text_delta", text: textChunk },
+        });
+      }
+
+      // Handle streaming tool calls
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          const idx = tc.index ?? 0;
+          if (!pendingToolCalls[idx]) {
+            pendingToolCalls[idx] = { id: "", name: "", arguments: "" };
+          }
+          if (tc.id) pendingToolCalls[idx].id = tc.id;
+          if (tc.function?.name) pendingToolCalls[idx].name += tc.function.name;
+          if (tc.function?.arguments) pendingToolCalls[idx].arguments += tc.function.arguments;
+        }
+      }
     } catch {
       // ignore parse errors
     }
@@ -79,7 +276,62 @@ export async function chatOpenRouter(
     parser.feed(decoder.decode(value));
   }
 
-  stopAnthropicMessage(res);
+  // ── Finalize: emit tool_use blocks if any ─────────────────────────
+
+  ensureMessageStarted();
+
+  // Close any open blocks
+  closeThinkingBlock();
+  closeContentBlock();
+
+  // Emit tool_use content blocks
+  const toolCallEntries = Object.values(pendingToolCalls);
+  if (toolCallEntries.length > 0) {
+    for (const tc of toolCallEntries) {
+      // Start tool_use content block
+      sendEvent(res, "content_block_start", {
+        type: "content_block_start",
+        index: contentIndex,
+        content_block: {
+          type: "tool_use",
+          id: tc.id,
+          name: tc.name,
+          input: {},
+        },
+      });
+
+      // Send the input as a delta
+      sendEvent(res, "content_block_delta", {
+        type: "content_block_delta",
+        index: contentIndex,
+        delta: {
+          type: "input_json_delta",
+          partial_json: tc.arguments,
+        },
+      });
+
+      // Stop tool_use content block
+      sendEvent(res, "content_block_stop", {
+        type: "content_block_stop",
+        index: contentIndex,
+      });
+
+      contentIndex++;
+    }
+  }
+
+  // Determine stop reason
+  const stopReason = toolCallEntries.length > 0 ? "tool_use" : "end_turn";
+
+  // Send message_delta and message_stop
+  sendEvent(res, "message_delta", {
+    type: "message_delta",
+    delta: { stop_reason: stopReason, stop_sequence: null },
+    usage: { output_tokens: 0 },
+  });
+  sendEvent(res, "message_stop", { type: "message_stop" });
+
+  res.raw.end();
 }
 
 function withStatus(status: number, message: string) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-glm",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Cross-platform installer for Claude Code with Z.AI GLM models, multi-provider proxy, and dangerously-skip-permissions shortcuts. Run with: npx claude-glm",
   "keywords": [
     "claude",