@push.rocks/smartagent 1.8.0 → 3.0.1

package/dist_ts_tools/tool.http.js

@@ -0,0 +1,65 @@
+import * as plugins from './plugins.js';
+export function httpTool() {
+    return {
+        http_get: plugins.tool({
+            description: 'Make an HTTP GET request and return the response.',
+            inputSchema: plugins.z.object({
+                url: plugins.z.string().describe('URL to request'),
+                headers: plugins.z
+                    .record(plugins.z.string())
+                    .optional()
+                    .describe('Request headers'),
+            }),
+            execute: async ({ url, headers, }) => {
+                let req = plugins.smartrequest.default.create().url(url);
+                if (headers) {
+                    req = req.headers(headers);
+                }
+                const response = await req.get();
+                let body;
+                try {
+                    const json = await response.json();
+                    body = JSON.stringify(json, null, 2);
+                }
+                catch {
+                    body = await response.text();
+                }
+                return plugins.truncateOutput(`HTTP ${response.status}\n${body}`).content;
+            },
+        }),
+        http_post: plugins.tool({
+            description: 'Make an HTTP POST request with a JSON body.',
+            inputSchema: plugins.z.object({
+                url: plugins.z.string().describe('URL to request'),
+                body: plugins.z
+                    .record(plugins.z.unknown())
+                    .optional()
+                    .describe('JSON body to send'),
+                headers: plugins.z
+                    .record(plugins.z.string())
+                    .optional()
+                    .describe('Request headers'),
+            }),
+            execute: async ({ url, body, headers, }) => {
+                let req = plugins.smartrequest.default.create().url(url);
+                if (headers) {
+                    req = req.headers(headers);
+                }
+                if (body) {
+                    req = req.json(body);
+                }
+                const response = await req.post();
+                let responseBody;
+                try {
+                    const json = await response.json();
+                    responseBody = JSON.stringify(json, null, 2);
+                }
+                catch {
+                    responseBody = await response.text();
+                }
+                return plugins.truncateOutput(`HTTP ${response.status}\n${responseBody}`).content;
+            },
+        }),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_tools/tool.json.d.ts

@@ -0,0 +1,2 @@
+import * as plugins from './plugins.js';
+export declare function jsonTool(): plugins.ToolSet;

package/dist_ts_tools/tool.json.js

@@ -0,0 +1,47 @@
+import * as plugins from './plugins.js';
+export function jsonTool() {
+    return {
+        json_validate: plugins.tool({
+            description: 'Validate a JSON string and optionally check for required fields.',
+            inputSchema: plugins.z.object({
+                jsonString: plugins.z.string().describe('JSON string to validate'),
+                requiredFields: plugins.z
+                    .array(plugins.z.string())
+                    .optional()
+                    .describe('Fields that must exist at the top level'),
+            }),
+            execute: async ({ jsonString, requiredFields, }) => {
+                try {
+                    const parsed = JSON.parse(jsonString);
+                    if (requiredFields?.length) {
+                        const missing = requiredFields.filter((f) => !(f in parsed));
+                        if (missing.length) {
+                            return `Invalid: missing required fields: ${missing.join(', ')}`;
+                        }
+                    }
+                    const type = Array.isArray(parsed) ? 'array' : typeof parsed;
+                    return `Valid JSON (${type})`;
+                }
+                catch (e) {
+                    return `Invalid JSON: ${e.message}`;
+                }
+            },
+        }),
+        json_transform: plugins.tool({
+            description: 'Parse a JSON string and return it pretty-printed.',
+            inputSchema: plugins.z.object({
+                jsonString: plugins.z.string().describe('JSON string to format'),
+            }),
+            execute: async ({ jsonString }) => {
+                try {
+                    const parsed = JSON.parse(jsonString);
+                    return JSON.stringify(parsed, null, 2);
+                }
+                catch (e) {
+                    return `Error parsing JSON: ${e.message}`;
+                }
+            },
+        }),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_tools/tool.shell.d.ts

@@ -0,0 +1,8 @@
+import * as plugins from './plugins.js';
+export interface IShellToolOptions {
+    /** Allowed commands whitelist. If empty, all commands are allowed. */
+    allowedCommands?: string[];
+    /** Working directory for shell execution */
+    cwd?: string;
+}
+export declare function shellTool(options?: IShellToolOptions): plugins.ToolSet;

package/dist_ts_tools/tool.shell.js

@@ -0,0 +1,40 @@
+import * as plugins from './plugins.js';
+export function shellTool(options) {
+    const smartshell = new plugins.smartshell.Smartshell({ executor: 'bash' });
+    return {
+        run_command: plugins.tool({
+            description: 'Execute a shell command. Provide the full command string. stdout and stderr are returned.',
+            inputSchema: plugins.z.object({
+                command: plugins.z.string().describe('The shell command to execute'),
+                cwd: plugins.z
+                    .string()
+                    .optional()
+                    .describe('Working directory for the command'),
+                timeout: plugins.z
+                    .number()
+                    .optional()
+                    .describe('Timeout in milliseconds'),
+            }),
+            execute: async ({ command, cwd, timeout, }) => {
+                // Validate against allowed commands whitelist
+                if (options?.allowedCommands?.length) {
+                    const baseCommand = command.split(/\s+/)[0];
+                    if (!options.allowedCommands.includes(baseCommand)) {
+                        return `Command "${baseCommand}" is not in the allowed commands list: ${options.allowedCommands.join(', ')}`;
+                    }
+                }
+                // Build full command string with cd prefix if cwd specified
+                const effectiveCwd = cwd ?? options?.cwd;
+                const fullCommand = effectiveCwd
+                    ? `cd ${JSON.stringify(effectiveCwd)} && ${command}`
+                    : command;
+                const execResult = await smartshell.exec(fullCommand);
+                const output = execResult.exitCode === 0
+                    ? execResult.stdout
+                    : `Exit code: ${execResult.exitCode}\nstdout:\n${execResult.stdout}\nstderr:\n${execResult.stderr ?? ''}`;
+                return plugins.truncateOutput(output).content;
+            },
+        }),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/npmextra.json

@@ -5,7 +5,7 @@
       "githost": "code.foss.global",
       "gitscope": "push.rocks",
       "gitrepo": "smartagent",
-      "description": "an agentic framework built on top of @push.rocks/smartai",
+      "description": "Agentic loop for ai-sdk (Vercel AI SDK). Wraps streamText with stopWhen for parallel multi-step tool execution. Built on @push.rocks/smartai.",
       "npmPackagename": "@push.rocks/smartagent",
       "license": "MIT",
       "projectDomain": "push.rocks"

package/package.json

@@ -1,33 +1,47 @@
 {
   "name": "@push.rocks/smartagent",
-  "version": "1.8.0",
+  "version": "3.0.1",
   "private": false,
-  "description": "an agentic framework built on top of @push.rocks/smartai",
+  "description": "Agentic loop for ai-sdk (Vercel AI SDK). Wraps streamText with stopWhen for parallel multi-step tool execution. Built on @push.rocks/smartai.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist_ts/index.js",
+      "types": "./dist_ts/index.d.ts"
+    },
+    "./tools": {
+      "import": "./dist_ts_tools/index.js",
+      "types": "./dist_ts_tools/index.d.ts"
+    },
+    "./compaction": {
+      "import": "./dist_ts_compaction/index.js",
+      "types": "./dist_ts_compaction/index.d.ts"
+    }
+  },
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "scripts": {
-    "test": "(tstest test/ --verbose)",
-    "build": "(tsbuild --web --allowimplicitany)",
+    "test": "(tstest test/ --verbose --logfile --timeout 120)",
+    "build": "(tsbuild tsfolders --allowimplicitany)",
     "buildDocs": "(tsdoc)"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^4.0.2",
-    "@git.zone/tsbundle": "^2.6.3",
+    "@git.zone/tsbuild": "^4.3.0",
+    "@git.zone/tsbundle": "^2.9.1",
     "@git.zone/tsrun": "^2.0.1",
-    "@git.zone/tstest": "^3.1.3",
-    "@types/node": "^25.0.2"
+    "@git.zone/tstest": "^3.3.0",
+    "@push.rocks/qenv": "^6.1.3",
+    "@types/node": "^25.3.5"
   },
   "dependencies": {
-    "@push.rocks/smartai": "^0.13.3",
-    "@push.rocks/smartbrowser": "^2.0.8",
-    "@push.rocks/smartdeno": "^1.2.0",
-    "@push.rocks/smartfs": "^1.2.0",
+    "@push.rocks/smartai": "^2.0.0",
+    "@push.rocks/smartfs": "^1.4.0",
     "@push.rocks/smartrequest": "^5.0.1",
-    "@push.rocks/smartshell": "^3.3.0",
-    "minimatch": "^10.1.1"
+    "@push.rocks/smartshell": "^3.3.7",
+    "ai": "^6.0.0",
+    "zod": "^3.25.0"
   },
   "packageManager": "pnpm@10.18.1+sha512.77a884a165cbba2d8d1c19e3b4880eee6d2fcabd0d879121e282196b80042351d5eb3ca0935fa599da1dc51265cc68816ad2bddd2a2de5ea9fdf92adbec7cd34",
   "repository": {
@@ -40,13 +54,11 @@
   "homepage": "https://code.foss.global/push.rocks/smartagent#readme",
   "files": [
     "ts/**/*",
-    "ts_web/**/*",
+    "ts_tools/**/*",
+    "ts_compaction/**/*",
     "dist/**/*",
     "dist_*/**/*",
-    "dist_ts/**/*",
-    "dist_ts_web/**/*",
     "assets/**/*",
-    "cli.js",
     "npmextra.json",
     "readme.md"
   ],

package/readme.hints.md

@@ -1,97 +1,51 @@
 # Project Readme Hints
 
 ## Overview
-`@push.rocks/smartagent` is a dual-agent agentic framework built on top of `@push.rocks/smartai`. It implements a Driver/Guardian architecture where the Driver proposes tool calls and the Guardian evaluates them against security policies.
+`@push.rocks/smartagent` v2.0.0 is an agentic loop built on Vercel AI SDK v6 via `@push.rocks/smartai`. It wraps `streamText` with `stopWhen: stepCountIs(n)` for parallel multi-step tool execution.
 
-## Architecture
-- **DualAgentOrchestrator**: Main entry point, coordinates Driver and Guardian agents
-- **DriverAgent**: Reasons about tasks, plans steps, proposes tool calls (supports both XML and native tool calling)
-- **GuardianAgent**: Evaluates tool calls against configured policies
-- **ToolRegistry**: Manages tool lifecycle, visibility, and discovery
-- **BaseToolWrapper**: Base class for creating custom tools
-- **plugins.ts**: Imports and re-exports smartai and other dependencies
+## Architecture (v2)
+- **`runAgent()`**: Pure async function — the core agentic loop. No class state.
+- **`ToolRegistry`**: Lightweight helper for collecting tools into a `ToolSet`.
+- **`truncateOutput()`**: Utility to prevent tool output from bloating context.
+- **`compactMessages()`**: Context overflow handler (separate subpath export).
 
-## Standard Tools (via registerStandardTools)
-1. **FilesystemTool** - File operations with scoping and exclusion patterns
-2. **HttpTool** - HTTP requests
-3. **ShellTool** - Secure shell commands (no injection possible)
-4. **BrowserTool** - Web page interaction via Puppeteer
-5. **DenoTool** - Sandboxed TypeScript/JavaScript execution
-
-## Additional Tools (must register manually)
-6. **JsonValidatorTool** - JSON validation and formatting (NOT in registerStandardTools)
-7. **ToolSearchTool** - AI-facing interface for tool discovery and activation
-8. **ExpertTool** - Wraps a DualAgentOrchestrator as a specialized expert tool
-
-## Tool Visibility System
-Tools can be registered with visibility modes:
-- **initial**: Always visible to Driver, included in system prompt (default)
-- **on-demand**: Only discoverable via search, must be activated before use
-
-```typescript
-// Register with visibility options
-orchestrator.registerTool(myTool, {
-  visibility: 'on-demand',
-  tags: ['database', 'sql'],
-  category: 'data'
-});
+## Source Layout
 ```
-
-## Expert/SubAgent System
-Experts are specialized agents wrapped as tools, enabling hierarchical agent architectures:
-
-```typescript
-orchestrator.registerExpert({
-  name: 'code_reviewer',
-  description: 'Reviews code for quality and best practices',
-  systemMessage: 'You are a code review expert...',
-  guardianPolicy: 'Allow read-only file access',
-  tools: [new FilesystemTool()],
-  visibility: 'on-demand',
-  tags: ['code', 'review']
-});
+ts/              → core: runAgent, ToolRegistry, truncateOutput, interfaces
+ts_tools/        → built-in tool factories (filesystem, shell, http, json)
+ts_compaction/   → compactMessages helper for onContextOverflow
 ```
 
-## Tool Search
-Enable tool discovery for the Driver:
-
-```typescript
-orchestrator.enableToolSearch();
-// Driver can now use:
-// - tools.search({"query": "database"})
-// - tools.list({})
-// - tools.activate({"name": "database_expert"})
-// - tools.details({"name": "filesystem"})
-```
-
-## Key Features
-- Token streaming support (`onToken` callback)
-- Vision support (pass images as base64)
-- Progress events (`onProgress` callback)
-- Scoped filesystem with exclusion patterns
-- Result truncation with configurable limits
-- History windowing to manage token usage
-- **Native tool calling mode** (`useNativeToolCalling: true`) for providers like Ollama
-- **Tool visibility system** (initial vs on-demand)
-- **Expert/SubAgent system** for hierarchical agents
-- **Tool search and discovery** via ToolSearchTool
-
-## Native Tool Calling
-When `useNativeToolCalling` is enabled:
-- Uses provider's built-in tool calling API instead of XML parsing
-- Tool names become `toolName_actionName` (e.g., `json_validate`)
-- Streaming includes `[THINKING]` and `[OUTPUT]` markers
-- More efficient for models that support it
+## Built-in Tools (ts_tools/)
+Each exports a factory returning a flat `ToolSet` (Record<string, Tool>):
+1. **filesystemTool()** → `read_file`, `write_file`, `list_directory`, `delete_file`
+2. **shellTool()** → `run_command`
+3. **httpTool()** → `http_get`, `http_post`
+4. **jsonTool()** → `json_validate`, `json_transform`
 
 ## Key Dependencies
-- `@push.rocks/smartai`: Multi-provider AI interface
-- `@push.rocks/smartfs`: Filesystem operations
-- `@push.rocks/smartshell`: Shell command execution
-- `@push.rocks/smartbrowser`: Browser automation
-- `@push.rocks/smartdeno`: Deno code execution
-- `@push.rocks/smartrequest`: HTTP requests
-- `minimatch`: Glob pattern matching for exclusions
+- `@push.rocks/smartai` ^2.0.0 — provider registry, `getModel()`, re-exports `tool`, `jsonSchema`
+- `ai` ^6.0.0 — Vercel AI SDK v6 (`streamText`, `stepCountIs`, `ModelMessage`, `ToolSet`)
+- `zod` ^3.25.0 — tool input schema definitions
+- `@push.rocks/smartfs`, `smartshell`, `smartrequest` — tool implementations
+
+## AI SDK v6 Key APIs
+- `streamText({ model, messages, tools, stopWhen: stepCountIs(20) })` — agentic loop
+- `tool({ description, inputSchema: z.object({...}), execute })` — define tools
+- `ModelMessage` — message type (replaces v4's `CoreMessage`)
+- `LanguageModelV3` — model type from `@ai-sdk/provider`
+- Result is `StreamTextResult` with PromiseLike properties (`await result.text`, etc.)
+
+## Package Exports
+- `.` → core (runAgent, ToolRegistry, truncateOutput, re-exports)
+- `./tools` → built-in tool factories
+- `./compaction` → compactMessages
+
+## Build
+- `pnpm build` → `tsbuild tsfolders --allowimplicitany`
+- Cross-folder imports via each folder's `plugins.ts` (tsbuild unpack resolves them)
 
 ## Test Structure
 - Tests use `@git.zone/tstest/tapbundle`
-- Tests must end with `export default tap.start();`
+- Tests must end with `export default tap.start()`
+- `pnpm test` → `tstest test/ --verbose`