@defai.digital/automatosx 9.2.0 → 9.2.3

package/dist/index.js

@@ -11084,20 +11084,73 @@ var init_adapter2 = __esm({
        */
       async execute(prompt, options) {
         const startTime = Date.now();
+        let totalTokens = 0;
         try {
           if (!await this.ensureSDKAvailable()) {
             throw new Error("ax-cli SDK not available. Install with: npm install @defai.digital/ax-cli");
           }
-          if (!this.agent || this.hasConfigChanged(options)) {
+          if (!this.agent || await this.hasConfigChanged(options)) {
             await this.initializeAgent(options);
           }
-          logger.debug("Executing via SDK", {
-            model: options.model,
+          logger.debug("Executing via SDK (streaming mode for token tracking)", {
             promptLength: prompt.length,
-            streaming: this.streamingEnabled
+            userWantsCallbacks: !!(options.onStream || options.onTool),
+            note: "SDK handles custom instructions and project memory"
           });
-          const result = await this.agent.processUserMessage(prompt);
-          const response = this.convertToExecutionResponse(result, prompt, startTime);
+          const historyLengthBefore = this.agent.getChatHistory().length;
+          for await (const chunk of this.agent.processUserMessageStream(prompt)) {
+            if (chunk.type === "token_count" && chunk.tokenCount) {
+              totalTokens += chunk.tokenCount;
+              logger.debug("Token count from stream", {
+                count: chunk.tokenCount,
+                total: totalTokens
+              });
+            }
+            if (options.onStream && (chunk.type === "content" || chunk.type === "reasoning")) {
+              try {
+                options.onStream({
+                  type: chunk.type === "reasoning" ? "thinking" : "content",
+                  content: chunk.content || chunk.reasoningContent,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+              } catch (error) {
+                logger.warn("Stream callback error", {
+                  error: error instanceof Error ? error.message : String(error)
+                });
+              }
+            }
+            if (options.onTool && chunk.type === "tool_calls" && chunk.toolCalls) {
+              try {
+                for (const toolCall of chunk.toolCalls) {
+                  options.onTool({
+                    name: toolCall.function.name,
+                    args: toolCall.function.arguments
+                  });
+                }
+              } catch (error) {
+                logger.warn("Tool callback error", {
+                  error: error instanceof Error ? error.message : String(error)
+                });
+              }
+            }
+          }
+          const fullHistory = this.agent.getChatHistory();
+          const result = fullHistory.slice(historyLengthBefore);
+          logger.debug("Chat history extraction", {
+            historyLengthBefore,
+            historyLengthAfter: fullHistory.length,
+            newEntries: result.length,
+            entryTypes: result.map((e) => e.type)
+          });
+          if (result.length === 0) {
+            logger.error("No new chat entries after execution", {
+              historyLengthBefore,
+              historyLengthAfter: fullHistory.length,
+              fullHistory: fullHistory.map((e) => ({ type: e.type, content: e.content?.substring(0, 50) }))
+            });
+            throw new Error("SDK did not add any new chat entries. This may indicate an execution error.");
+          }
+          const response = this.convertToExecutionResponse(result, prompt, startTime, totalTokens);
           logger.info("SDK execution successful", {
             model: response.model,
             contentLength: response.content.length,
@@ -11108,64 +11161,96 @@ var init_adapter2 = __esm({
         } catch (error) {
           logger.error("SDK execution failed", {
             error: error instanceof Error ? error.message : String(error),
-            model: options.model
+            note: "Model configured via ax-cli setup"
           });
           throw this.mapError(error);
         }
       }
       /**
        * Initialize or reinitialize agent
+       *
+       * IMPORTANT: The SDK loads ALL credentials (API key, base URL, model) from
+       * ~/.ax-cli/config.json which is created by running "ax-cli setup".
+       *
+       * We do NOT pass credentials to the SDK - it manages its own configuration.
        */
       async initializeAgent(options) {
+        const { createAgent } = await import('@defai.digital/ax-cli/sdk');
         try {
-          const { createAgent, initializeSDK } = await import('@defai.digital/ax-cli/sdk');
           const config = {
-            apiKey: options.apiKey,
-            model: options.model || "glm-4.6",
-            baseURL: options.baseUrl,
             maxToolRounds: options.maxToolRounds || 400
           };
-          await initializeSDK({
-            apiKey: config.apiKey,
-            model: config.model,
-            baseURL: config.baseURL
-          });
-          logger.debug("Initializing SDK agent", {
-            model: config.model,
+          logger.debug("Creating SDK agent (credentials from ax-cli settings)", {
             maxToolRounds: config.maxToolRounds,
-            reuse: this.reuseEnabled
+            reuse: this.reuseEnabled,
+            note: "SDK loads apiKey, baseURL, model from ~/.ax-cli/config.json"
+          });
+          this.agent = await createAgent({
+            maxToolRounds: config.maxToolRounds
           });
-          this.agent = await createAgent(config);
           this.agentConfig = config;
           if (this.streamingEnabled) {
             this.setupEventHandlers();
           }
-          logger.info("SDK agent initialized", {
-            model: config.model
+          logger.info("SDK agent initialized successfully", {
+            maxToolRounds: config.maxToolRounds,
+            note: "Using credentials from ax-cli setup"
           });
-        } catch (error) {
+        } catch (err) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          const errorMsg = error.message.toLowerCase();
+          if (errorMsg.includes("setup") || errorMsg.includes("not configured")) {
+            logger.error("ax-cli setup required", {
+              error: error.message,
+              solution: "Run: ax-cli setup"
+            });
+            throw new Error(
+              `ax-cli setup has not been run. Please run "ax-cli setup" to configure your API key, model, and base URL. Original error: ${error.message}`
+            );
+          }
+          if (errorMsg.includes("api key") || errorMsg.includes("apikey")) {
+            logger.error("API key not configured", {
+              error: error.message,
+              solution: "Run: ax-cli setup"
+            });
+            throw new Error(
+              `No API key configured in ax-cli settings. Please run "ax-cli setup" to configure your credentials. Original error: ${error.message}`
+            );
+          }
+          if (errorMsg.includes("base url") || errorMsg.includes("baseurl") || errorMsg.includes("endpoint")) {
+            logger.error("Base URL not configured", {
+              error: error.message,
+              solution: "Run: ax-cli setup"
+            });
+            throw new Error(
+              `No base URL configured in ax-cli settings. Please run "ax-cli setup" to configure your AI provider endpoint. Original error: ${error.message}`
+            );
+          }
           logger.error("Failed to initialize SDK agent", {
-            error: error instanceof Error ? error.message : String(error)
+            error: error.message
           });
-          throw new Error(`Failed to initialize SDK agent: ${error instanceof Error ? error.message : String(error)}`);
+          throw new Error(`Failed to initialize SDK agent: ${error.message}`);
         }
       }
       /**
        * Check if agent config has changed (requires new agent)
+       *
+       * Since SDK manages credentials via settings, we only track maxToolRounds
        */
-      hasConfigChanged(options) {
+      async hasConfigChanged(options) {
         if (!this.agentConfig) return true;
-        const changed = this.agentConfig.model !== (options.model || "glm-4.6") || this.agentConfig.apiKey !== options.apiKey || this.agentConfig.baseURL !== options.baseUrl || this.agentConfig.maxToolRounds !== (options.maxToolRounds || 400);
+        const changed = this.agentConfig.maxToolRounds !== (options.maxToolRounds || 400);
         if (changed) {
           logger.debug("Agent config changed, will reinitialize", {
-            oldModel: this.agentConfig.model,
-            newModel: options.model || "glm-4.6"
+            oldMaxToolRounds: this.agentConfig.maxToolRounds,
+            newMaxToolRounds: options.maxToolRounds || 400,
+            note: "SDK credentials managed by ax-cli setup"
           });
         }
         return changed;
       }
       /**
-       * Set up streaming event handlers
+       * Set up streaming event handlers (for initialization)
        */
       setupEventHandlers() {
         if (!this.agent) return;
@@ -11192,6 +11277,50 @@ var init_adapter2 = __esm({
           });
         }
       }
+      /**
+       * Set up streaming callbacks for execution
+       */
+      setupStreamingCallbacks(options) {
+        if (!this.agent) return;
+        try {
+          this.agent.removeAllListeners("stream");
+          this.agent.removeAllListeners("tool");
+          if (options.onStream) {
+            this.agent.on("stream", (chunk) => {
+              try {
+                options.onStream({
+                  type: chunk.type || "content",
+                  content: chunk.content,
+                  tool: chunk.tool,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+              } catch (error) {
+                logger.warn("Stream callback error", {
+                  error: error instanceof Error ? error.message : String(error)
+                });
+              }
+            });
+          }
+          if (options.onTool) {
+            this.agent.on("tool", (data) => {
+              try {
+                options.onTool({
+                  name: data.name,
+                  args: data.args
+                });
+              } catch (error) {
+                logger.warn("Tool callback error", {
+                  error: error instanceof Error ? error.message : String(error)
+                });
+              }
+            });
+          }
+        } catch (error) {
+          logger.warn("Failed to setup streaming callbacks", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
       /**
        * Convert SDK response to ExecutionResponse format
        *
@@ -11201,69 +11330,135 @@ var init_adapter2 = __esm({
        *   { type: "assistant", content: "...", timestamp: "..." }
        * ]
        *
-       * Note: SDK doesn't expose token counts, so we estimate them based on content length.
+       * Token usage priority: SDK events (totalTokens) > ChatEntry.usage > estimation fallback
        */
-      convertToExecutionResponse(result, prompt, startTime) {
+      convertToExecutionResponse(result, prompt, startTime, totalTokensFromEvents = 0) {
         const latencyMs = Date.now() - startTime;
         if (Array.isArray(result)) {
           const assistantMessages = result.filter((entry) => entry.type === "assistant");
           if (assistantMessages.length === 0) {
-            throw new Error("No assistant response found in SDK result");
+            logger.error("No assistant message in result", {
+              resultLength: result.length,
+              entryTypes: result.map((e) => e.type),
+              entries: result.map((e) => ({
+                type: e.type,
+                content: e.content?.substring(0, 100),
+                hasToolCalls: !!e.toolCalls,
+                hasToolResults: !!e.toolResult
+              }))
+            });
+            throw new Error(`No assistant response found in SDK result. Got ${result.length} entries with types: ${result.map((e) => e.type).join(", ")}`);
           }
           const lastAssistant = assistantMessages[assistantMessages.length - 1];
           const content2 = lastAssistant.content || "";
-          const usage2 = lastAssistant.usage || lastAssistant.tokens || {};
-          const actualTokens2 = {
-            prompt: usage2.prompt || usage2.input || usage2.promptTokens,
-            completion: usage2.completion || usage2.output || usage2.completionTokens,
-            total: usage2.total || usage2.totalTokens
-          };
-          const estimated2 = TokenEstimator.estimateUsage(prompt, content2);
-          const finalTokens2 = TokenEstimator.mergeWithActual(estimated2, actualTokens2);
-          logger.debug("Token usage", {
-            estimated: TokenEstimator.format(estimated2, true),
-            actual: actualTokens2.total ? TokenEstimator.format(actualTokens2) : "not available",
-            final: TokenEstimator.format(finalTokens2)
-          });
-          const model2 = lastAssistant.model || this.agentConfig?.model || "glm-4.6";
-          let finishReason2 = "stop";
-          if (lastAssistant.finishReason) {
-            finishReason2 = lastAssistant.finishReason;
-          } else if (lastAssistant.stopReason) {
-            finishReason2 = lastAssistant.stopReason === "max_tokens" ? "length" : "stop";
+          let finalTokens2;
+          if (totalTokensFromEvents > 0) {
+            const estimated = TokenEstimator.estimateUsage(prompt, content2);
+            finalTokens2 = {
+              prompt: estimated.prompt,
+              // Estimated split
+              completion: estimated.completion,
+              // Estimated split
+              total: totalTokensFromEvents
+              // Actual total from events
+            };
+            logger.info("Using token count from SDK events", {
+              tokens: TokenEstimator.format(finalTokens2),
+              accuracy: "100% (total), 80-90% (split)",
+              source: "token_count events"
+            });
+          } else {
+            const usage = lastAssistant.usage || lastAssistant.tokens || {};
+            const actualTokens = {
+              prompt: usage.prompt_tokens || usage.prompt || usage.input || usage.promptTokens || 0,
+              completion: usage.completion_tokens || usage.completion || usage.output || usage.completionTokens || 0,
+              total: usage.total_tokens || usage.total || usage.totalTokens || 0
+            };
+            const hasActualTokens = actualTokens.total > 0;
+            if (hasActualTokens) {
+              finalTokens2 = {
+                prompt: actualTokens.prompt,
+                completion: actualTokens.completion,
+                total: actualTokens.total
+              };
+              logger.info("Using token counts from ChatEntry.usage", {
+                tokens: TokenEstimator.format(finalTokens2),
+                accuracy: "100%",
+                source: "ChatEntry.usage"
+              });
+            } else {
+              finalTokens2 = TokenEstimator.estimateUsage(prompt, content2);
+              logger.warn("SDK did not provide token counts, using estimation", {
+                tokens: TokenEstimator.format(finalTokens2, true),
+                accuracy: "80-90% (estimated)",
+                source: "estimation"
+              });
+            }
           }
+          const model2 = this.agent.getCurrentModel();
+          const finishReason2 = "stop";
           return {
             content: content2,
             model: model2,
             tokensUsed: finalTokens2,
             latencyMs,
             finishReason: finishReason2,
-            cached: lastAssistant.cached || false
+            cached: false
+            // SDK doesn't expose cache status via ChatEntry
           };
         }
         const content = typeof result === "string" ? result : result.content || result.text || "";
-        const usage = result.usage || result.tokens || {};
-        const actualTokens = {
-          prompt: usage.prompt || usage.input || usage.promptTokens,
-          completion: usage.completion || usage.output || usage.completionTokens,
-          total: usage.total || usage.totalTokens
-        };
-        const estimated = TokenEstimator.estimateUsage(prompt, content);
-        const finalTokens = TokenEstimator.mergeWithActual(estimated, actualTokens);
-        const model = result.model || this.agentConfig?.model || "glm-4.6";
-        let finishReason = "stop";
-        if (result.finishReason) {
-          finishReason = result.finishReason;
-        } else if (result.stopReason) {
-          finishReason = result.stopReason === "max_tokens" ? "length" : "stop";
+        let finalTokens;
+        if (totalTokensFromEvents > 0) {
+          const estimated = TokenEstimator.estimateUsage(prompt, content);
+          finalTokens = {
+            prompt: estimated.prompt,
+            completion: estimated.completion,
+            total: totalTokensFromEvents
+          };
+          logger.info("Using token count from SDK events (fallback path)", {
+            tokens: TokenEstimator.format(finalTokens),
+            accuracy: "100% (total), 80-90% (split)",
+            source: "token_count events"
+          });
+        } else {
+          const usage = result.usage || result.tokens || {};
+          const actualTokens = {
+            prompt: usage.prompt_tokens || usage.prompt || usage.input || usage.promptTokens || 0,
+            completion: usage.completion_tokens || usage.completion || usage.output || usage.completionTokens || 0,
+            total: usage.total_tokens || usage.total || usage.totalTokens || 0
+          };
+          const hasActualTokens = actualTokens.total > 0;
+          if (hasActualTokens) {
+            finalTokens = {
+              prompt: actualTokens.prompt,
+              completion: actualTokens.completion,
+              total: actualTokens.total
+            };
+            logger.info("Using token counts from response.usage (fallback path)", {
+              tokens: TokenEstimator.format(finalTokens),
+              accuracy: "100%",
+              source: "response.usage"
+            });
+          } else {
+            finalTokens = TokenEstimator.estimateUsage(prompt, content);
+            logger.warn("SDK did not provide token counts (fallback path), using estimation", {
+              tokens: TokenEstimator.format(finalTokens, true),
+              accuracy: "80-90% (estimated)",
+              source: "estimation"
+            });
+          }
         }
+        const model = this.agent.getCurrentModel();
+        const finishReason = "stop";
         return {
           content,
           model,
           tokensUsed: finalTokens,
           latencyMs,
           finishReason,
-          cached: result.cached || false
+          cached: false
+          // SDK doesn't expose cache status
         };
       }
       /**
@@ -11333,8 +11528,8 @@ var init_adapter2 = __esm({
        */
       async getVersion() {
         try {
-          const { GLM_MODELS } = await import('@defai.digital/ax-cli/sdk');
-          return "3.4.6";
+          await import('@defai.digital/ax-cli/sdk');
+          return "3.7.0+";
         } catch (error) {
           logger.warn("Failed to get SDK version", {
             error: error instanceof Error ? error.message : String(error)
@@ -11360,9 +11555,7 @@ var init_adapter2 = __esm({
       async destroy() {
         if (this.agent) {
           try {
-            if (typeof this.agent.cleanup === "function") {
-              await this.agent.cleanup();
-            }
+            this.agent.dispose();
             this.agent = null;
             this.agentConfig = null;
             logger.debug("SDK agent destroyed");
@@ -11435,8 +11628,8 @@ var init_hybrid_adapter = __esm({
           throw new Error("SDK adapter not initialized");
         }
         logger.debug("Executing via SDK", {
-          model: options.model,
-          promptLength: prompt.length
+          promptLength: prompt.length,
+          note: "Model configured via ax-cli setup"
         });
         return await this.sdkAdapter.execute(prompt, options);
       }
@@ -11448,7 +11641,7 @@ var init_hybrid_adapter = __esm({
           throw new Error("CLI adapter not initialized");
         }
         logger.debug("Executing via CLI", {
-          model: options.model,
+          model: options.model || "(from ax-cli setup)",
           promptLength: prompt.length
         });
         return await this.cliAdapter.execute(prompt, options);
@@ -11640,9 +11833,9 @@ var init_ax_cli_provider = __esm({
         });
         logger.info("AxCliProvider initialized", {
           mode,
-          provider: config.axCli?.provider || "glm",
-          model: config.axCli?.model || "glm-4.6",
-          sdkOptions: config.axCliSdk
+          model: config.axCli?.model || "(from ax-cli setup)",
+          sdkOptions: config.axCliSdk,
+          note: "Provider configured via ax-cli setup"
         });
       }
       /**
@@ -11655,17 +11848,21 @@ var init_ax_cli_provider = __esm({
       async execute(request) {
         const axCliConfig = this.config.axCli || {};
         const options = {
-          provider: axCliConfig.provider || "glm",
-          model: request.model || axCliConfig.model || "glm-4.6",
+          model: request.model || axCliConfig.model,
+          // Optional model override
           maxToolRounds: axCliConfig.maxToolRounds || 400,
           timeout: this.config.timeout,
+          // Note: apiKey and baseUrl are ignored by SDK adapter (v3.7.0+)
+          // SDK loads credentials from ax-cli setup (~/.ax-cli/config.json)
           apiKey: axCliConfig.apiKey,
+          // Only used by CLI adapter (deprecated)
           baseUrl: axCliConfig.baseUrl
+          // Only used by CLI adapter (deprecated)
         };
         logger.debug("Executing task via ax-cli", {
-          provider: options.provider,
-          model: options.model,
-          promptLength: request.prompt.length
+          model: options.model || "(from ax-cli setup)",
+          promptLength: request.prompt.length,
+          note: "Provider configured via ax-cli setup"
         });
         try {
           const response = await this.adapter.execute(request.prompt, options);
@@ -11679,8 +11876,7 @@ var init_ax_cli_provider = __esm({
         } catch (error) {
           logger.error("Task execution failed", {
             error: error instanceof Error ? error.message : String(error),
-            provider: options.provider,
-            model: options.model
+            model: options.model || "(from ax-cli setup)"
           });
           throw error;
         }
@@ -13120,6 +13316,41 @@ function calculateMaxConcurrentAgents(staticLimit) {
 init_esm_shims();
 var PRECOMPILED_CONFIG = {
   "providers": {
+    "ax-cli": {
+      "enabled": true,
+      "priority": 4,
+      "timeout": 27e5,
+      "command": "ax-cli",
+      "mode": "auto",
+      "healthCheck": {
+        "enabled": true,
+        "interval": 3e5,
+        "timeout": 5e3
+      },
+      "circuitBreaker": {
+        "enabled": true,
+        "failureThreshold": 3,
+        "recoveryTimeout": 6e4
+      },
+      "processManagement": {
+        "gracefulShutdownTimeout": 5e3,
+        "forceKillDelay": 1e3
+      },
+      "versionDetection": {
+        "timeout": 5e3,
+        "forceKillDelay": 1e3,
+        "cacheEnabled": true
+      },
+      "limitTracking": {
+        "enabled": true,
+        "window": "daily",
+        "resetHourUtc": 0
+      },
+      "axCliSdk": {
+        "streamingEnabled": true,
+        "reuseEnabled": true
+      }
+    },
     "claude-code": {
       "enabled": true,
       "priority": 3,
@@ -36475,32 +36706,29 @@ Complexity Score: ${complexity.score}/10
           minVersion: geminiConfig.minVersion
         }));
       }
-      if (config.providers["glm"]?.enabled) {
+      const axCliConfigKey = config.providers["ax-cli"] ? "ax-cli" : config.providers["glm"] ? "glm" : null;
+      if (axCliConfigKey && config.providers[axCliConfigKey]?.enabled) {
         try {
-          const { AxCliProvider: AxCliProvider2, GlmProvider: GlmProvider2 } = await Promise.resolve().then(() => (init_ax_cli_provider(), ax_cli_provider_exports));
-          const glmConfig = config.providers["glm"];
-          if (glmConfig) {
-            providers.push(new GlmProvider2({
-              name: "glm",
-              enabled: true,
-              priority: glmConfig.priority ?? 4,
-              // Default priority
-              timeout: glmConfig.timeout ?? 12e4,
-              // Default 2 minutes
-              command: glmConfig.command || "ax-cli",
-              // v11.0.0: ax-cli only
-              // Phase 2: Enhanced CLI detection parameters
-              customPath: glmConfig.customPath,
-              versionArg: glmConfig.versionArg,
-              minVersion: glmConfig.minVersion,
-              // v11.0.0: Simplified ax-cli configuration
-              axCli: glmConfig.axCli
-            }));
-          } else {
-            logger.warn("GLM provider enabled but configuration is missing");
+          const { AxCliProvider: AxCliProvider2 } = await Promise.resolve().then(() => (init_ax_cli_provider(), ax_cli_provider_exports));
+          const axCliConfig = config.providers[axCliConfigKey];
+          providers.push(new AxCliProvider2({
+            name: "ax-cli",
+            enabled: true,
+            priority: axCliConfig.priority ?? 4,
+            timeout: axCliConfig.timeout ?? 12e4,
+            command: axCliConfig.command || "ax-cli",
+            mode: axCliConfig.mode || "auto",
+            customPath: axCliConfig.customPath,
+            versionArg: axCliConfig.versionArg,
+            minVersion: axCliConfig.minVersion,
+            axCli: axCliConfig.axCli,
+            axCliSdk: axCliConfig.axCliSdk
+          }));
+          if (axCliConfigKey === "glm") {
+            logger.warn('Using deprecated "glm" provider config. Please rename to "ax-cli" in ax.config.json');
           }
         } catch (error) {
-          logger.error("Failed to initialize GLM provider", { error });
+          logger.error("Failed to initialize ax-cli provider", { error });
         }
       }
       if (config.providers["openai"]?.enabled) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@defai.digital/automatosx",
-  "version": "9.2.0",
-  "description": "AI Agent Orchestration Platform",
+  "version": "9.2.3",
+  "description": "AutomatosX is a unified automation core that orchestrates AI agents, workflows, and memory",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -86,7 +86,7 @@
     "vitest": "^3.2.4"
   },
   "dependencies": {
-    "@defai.digital/ax-cli": "^3.4.6",
+    "@defai.digital/ax-cli": "^3.6.2",
     "@iarna/toml": "^2.2.5",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",