@zeulewan/glueclaw-provider 1.2.3 → 1.4.0

package/README.md

@@ -50,6 +50,18 @@ The only way this breaks is if Anthropic changes how `--system-prompt` or `--out
 
 Switch in TUI: `/model glueclaw/glueclaw-opus`
 
+## Configuration
+
+| Env var                       | Default  | Description                                                                                                                                                                                                                                                                 |
+| ----------------------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `GLUECLAW_REQUEST_TIMEOUT_MS` | `120000` | Maximum time (in milliseconds) to wait for the Claude CLI subprocess to complete a single request before it is terminated. Increase if long-running tool calls or extensive reasoning trip the default 120s limit. Invalid or non-positive values fall back to the default. |
+
+Example (10 minute timeout):
+
+```bash
+export GLUECLAW_REQUEST_TIMEOUT_MS=600000
+```
+
 ## Notes
 
 - Tested with Telegram and OpenClaw TUI

package/index.ts

@@ -1,9 +1,11 @@
+import { basename } from "node:path";
 import {
   definePluginEntry,
   type OpenClawPluginApi,
 } from "openclaw/plugin-sdk/plugin-entry";
 import { createClaudeCliStreamFn } from "./src/stream.js";
 import { MODEL_CATALOG } from "./src/catalog.js";
+import { resolveSessionKey } from "./src/session-key.js";
 
 const PROVIDER_ID = "glueclaw";
 const PROVIDER_LABEL = "GlueClaw";
@@ -18,6 +20,17 @@ const MODEL_MAP: Readonly<Record<string, string>> = {
   "glueclaw-haiku": "claude-haiku-4-5",
 };
 
+const DEFAULT_REQUEST_TIMEOUT_MS = 120_000;
+
+function resolveRequestTimeoutMs(): number {
+  const raw = process.env.GLUECLAW_REQUEST_TIMEOUT_MS;
+  if (raw === undefined || raw === "") return DEFAULT_REQUEST_TIMEOUT_MS;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0)
+    return DEFAULT_REQUEST_TIMEOUT_MS;
+  return parsed;
+}
+
 export default definePluginEntry({
   register(api: OpenClawPluginApi): void {
     const authProfile = () =>
@@ -69,11 +82,19 @@ export default definePluginEntry({
           },
         }),
       },
-      createStreamFn: (ctx: { modelId: string; agentDir?: string }) => {
+      createStreamFn: (ctx: {
+        modelId: string;
+        agentDir?: string;
+        sessionId?: string;
+        sessionKey?: string;
+      }) => {
         const realModel = MODEL_MAP[ctx.modelId] ?? ctx.modelId;
+        const agentId = ctx.agentDir ? basename(ctx.agentDir) : undefined;
         return createClaudeCliStreamFn({
-          sessionKey: ctx.agentDir ?? "default",
+          sessionKey: resolveSessionKey(ctx),
+          agentId,
           modelOverride: realModel,
+          requestTimeoutMs: resolveRequestTimeoutMs(),
         });
       },
       resolveSyntheticAuth: () => ({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeulewan/glueclaw-provider",
-  "version": "1.2.3",
+  "version": "1.4.0",
   "description": "GlueClaw - Claude CLI subprocess provider for Max subscription",
   "type": "module",
   "engines": {

package/src/stream.ts

@@ -170,6 +170,7 @@ function evictSessions(): void {
 export function createClaudeCliStreamFn(opts: {
   claudeBin?: string;
   sessionKey?: string;
+  agentId?: string;
   modelOverride?: string;
   requestTimeoutMs?: number;
 }): StreamFn {
@@ -194,14 +195,17 @@ export function createClaudeCliStreamFn(opts: {
           "--verbose",
           "--include-partial-messages",
         ];
-        // Resume session for multi-turn conversation memory
+        // Resume session for multi-turn conversation memory.
+        // Always re-inject the system prompt — on resumptions the CLI would
+        // otherwise stick to whatever identity was used on the first turn,
+        // leaving no way for callers to reinforce or correct an agent's
+        // identity across turns.
         const sessionKey = `glueclaw:${opts.sessionKey ?? "default"}`;
         const existingSessionId = sessionMap.get(sessionKey);
         if (existingSessionId) {
           args.push("--resume", existingSessionId);
-        } else {
-          if (cleanPrompt) args.push("--system-prompt", cleanPrompt);
         }
+        if (cleanPrompt) args.push("--system-prompt", cleanPrompt);
         if (resolvedModel) args.push("--model", resolvedModel);
 
         // Debug: log args for resume troubleshooting
@@ -233,7 +237,7 @@ export function createClaudeCliStreamFn(opts: {
           args.push("--strict-mcp-config", "--mcp-config", mcp.path);
           env.OPENCLAW_MCP_TOKEN = loopback.token;
           env.OPENCLAW_MCP_SESSION_KEY = opts.sessionKey ?? "";
-          env.OPENCLAW_MCP_AGENT_ID = "main";
+          env.OPENCLAW_MCP_AGENT_ID = opts.agentId ?? "main";
           env.OPENCLAW_MCP_ACCOUNT_ID = "";
           env.OPENCLAW_MCP_MESSAGE_CHANNEL = "";
         }
@@ -356,14 +360,46 @@ export function createClaudeCliStreamFn(opts: {
             continue;
           }
 
-          // Complete assistant message - only use if we didn't get streaming deltas
+          // Assistant message — may contain tool_use and/or text content blocks
           if (type === "assistant") {
-            if (!started) {
-              const content = data.message?.content;
-              if (content) {
+            const content = data.message?.content;
+            if (content) {
+              // Emit tool call events for any tool_use blocks
+              for (const block of content) {
+                if (block.type === "tool_use") {
+                  const b = block as {
+                    type: string;
+                    id: string;
+                    name: string;
+                    input: Record<string, unknown>;
+                  };
+                  startStream();
+                  const toolCall = {
+                    type: "toolCall" as const,
+                    id: b.id,
+                    name: b.name,
+                    arguments: (b.input ?? {}) as Record<string, any>,
+                  };
+                  stream.push({
+                    type: "toolcall_start",
+                    contentIndex: 0,
+                    toolName: b.name,
+                    partial: buildMsg(info, text, buildUsage()),
+                  } as any);
+                  stream.push({
+                    type: "toolcall_end",
+                    contentIndex: 0,
+                    toolCall,
+                    partial: buildMsg(info, text, buildUsage()),
+                  });
+                }
+              }
+
+              // Handle text blocks (only if we haven't streamed via deltas)
+              if (!streamed) {
                 const textBlocks = content
-                  .filter((b) => b.type === "text" && b.text)
-                  .map((b) => b.text ?? "");
+                  .filter((b: any) => b.type === "text" && b.text)
+                  .map((b: any) => b.text ?? "");
                 if (textBlocks.length > 0) {
                   const fullText = textBlocks.join("\n");
                   startStream();