@psnext/slingcli 2.4.20260528-1 → 2.5.20260602-1

package/node_modules/@aws-sdk/nested-clients/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/nested-clients",
-  "version": "3.997.12",
+  "version": "3.997.13",
   "description": "Nested clients for AWS SDK packages.",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
@@ -29,12 +29,12 @@
   "dependencies": {
     "@aws-crypto/sha256-browser": "5.2.0",
     "@aws-crypto/sha256-js": "5.2.0",
-    "@aws-sdk/core": "^3.974.14",
-    "@aws-sdk/signature-v4-multi-region": "^3.996.29",
+    "@aws-sdk/core": "^3.974.15",
+    "@aws-sdk/signature-v4-multi-region": "^3.996.30",
     "@aws-sdk/types": "^3.973.9",
-    "@smithy/core": "^3.24.3",
-    "@smithy/fetch-http-handler": "^5.4.3",
-    "@smithy/node-http-handler": "^4.7.3",
+    "@smithy/core": "^3.24.5",
+    "@smithy/fetch-http-handler": "^5.4.5",
+    "@smithy/node-http-handler": "^4.7.5",
     "@smithy/types": "^4.14.2",
     "tslib": "^2.6.2"
   },

package/node_modules/@aws-sdk/signature-v4-multi-region/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/signature-v4-multi-region",
-  "version": "3.996.29",
+  "version": "3.996.30",
   "scripts": {
     "build": "concurrently 'yarn:build:types' 'yarn:build:es' && yarn build:cjs",
     "build:cjs": "node ../../scripts/compilation/inline signature-v4-multi-region",
@@ -26,7 +26,7 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@aws-sdk/types": "^3.973.9",
-    "@smithy/signature-v4": "^5.4.2",
+    "@smithy/signature-v4": "^5.4.5",
     "@smithy/types": "^4.14.2",
     "tslib": "^2.6.2"
   },

package/node_modules/@earendil-works/pi-agent-core/dist/harness/agent-harness.js

@@ -50,6 +50,16 @@ function mergeHeaders(...headers) {
     }
     return hasHeaders ? merged : undefined;
 }
+function findDuplicateNames(names) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const name of names) {
+        if (seen.has(name))
+            duplicates.add(name);
+        seen.add(name);
+    }
+    return [...duplicates];
+}
 function applyStreamOptionsPatch(base, patch) {
     const result = cloneStreamOptions(base);
     if (!patch)
@@ -140,12 +150,17 @@ export class AgentHarness {
         this.streamOptions = cloneStreamOptions(options.streamOptions);
         this.systemPrompt = options.systemPrompt;
         this.getApiKeyAndHeaders = options.getApiKeyAndHeaders;
+        this.validateUniqueNames((options.tools ?? []).map((tool) => tool.name), "Duplicate tool name(s)");
         for (const tool of options.tools ?? []) {
             this.tools.set(tool.name, tool);
         }
         this.model = options.model;
         this.thinkingLevel = options.thinkingLevel ?? "off";
-        this.activeToolNames = options.activeToolNames ?? (options.tools ?? []).map((tool) => tool.name);
+        this.activeToolNames = options.activeToolNames
+            ? [...options.activeToolNames]
+            : (options.tools ?? []).map((tool) => tool.name);
+        this.validateUniqueNames(this.activeToolNames, "Duplicate active tool name(s)");
+        this.validateToolNames(this.activeToolNames);
         this.steeringQueueMode = options.steeringMode ?? "one-at-a-time";
         this.followUpQueueMode = options.followUpMode ?? "one-at-a-time";
     }
@@ -379,7 +394,13 @@ export class AgentHarness {
             getFollowUpMessages: async () => this.drainQueuedMessages(this.followUpQueue, this.followUpQueueMode),
         };
     }
+    validateUniqueNames(names, message) {
+        const duplicates = findDuplicateNames(names);
+        if (duplicates.length > 0)
+            throw new AgentHarnessError("invalid_argument", `${message}: ${duplicates.join(", ")}`);
+    }
     validateToolNames(toolNames, tools = this.tools) {
+        this.validateUniqueNames(toolNames, "Duplicate active tool name(s)");
         const missing = toolNames.filter((name) => !tools.has(name));
         if (missing.length > 0)
             throw new AgentHarnessError("invalid_argument", `Unknown tool(s): ${missing.join(", ")}`);
@@ -396,6 +417,9 @@ export class AgentHarness {
             else if (write.type === "thinking_level_change") {
                 await this.session.appendThinkingLevelChange(write.thinkingLevel);
             }
+            else if (write.type === "active_tools_change") {
+                await this.session.appendActiveToolsChange(write.activeToolNames);
+            }
             else if (write.type === "custom") {
                 await this.session.appendCustomEntry(write.customType, write.data);
             }
@@ -756,9 +780,6 @@ export class AgentHarness {
     getModel() {
         return this.model;
     }
-    getThinkingLevel() {
-        return this.thinkingLevel;
-    }
     async setModel(model) {
         try {
             const previousModel = this.model;
@@ -769,12 +790,15 @@ export class AgentHarness {
                 this.pendingSessionWrites.push({ type: "model_change", provider: model.provider, modelId: model.id });
             }
             this.model = model;
-            await this.emitOwn({ type: "model_select", model, previousModel, source: "set" });
+            await this.emitOwn({ type: "model_update", model, previousModel, source: "set" });
         }
         catch (error) {
             throw normalizeHarnessError(error, "session");
         }
     }
+    getThinkingLevel() {
+        return this.thinkingLevel;
+    }
     async setThinkingLevel(level) {
         try {
             const previousLevel = this.thinkingLevel;
@@ -785,16 +809,67 @@ export class AgentHarness {
                 this.pendingSessionWrites.push({ type: "thinking_level_change", thinkingLevel: level });
             }
             this.thinkingLevel = level;
-            await this.emitOwn({ type: "thinking_level_select", level, previousLevel });
+            await this.emitOwn({ type: "thinking_level_update", level, previousLevel });
         }
         catch (error) {
             throw normalizeHarnessError(error, "session");
         }
     }
+    getTools() {
+        return [...this.tools.values()];
+    }
+    async setTools(tools, activeToolNames) {
+        try {
+            this.validateUniqueNames(tools.map((tool) => tool.name), "Duplicate tool name(s)");
+            const nextTools = new Map(tools.map((tool) => [tool.name, tool]));
+            const nextActiveToolNames = activeToolNames ? [...activeToolNames] : this.activeToolNames;
+            this.validateToolNames(nextActiveToolNames, nextTools);
+            const previousToolNames = [...this.tools.keys()];
+            const previousActiveToolNames = [...this.activeToolNames];
+            if (this.phase === "idle") {
+                await this.session.appendActiveToolsChange(nextActiveToolNames);
+            }
+            else {
+                this.pendingSessionWrites.push({ type: "active_tools_change", activeToolNames: [...nextActiveToolNames] });
+            }
+            this.tools = nextTools;
+            this.activeToolNames = [...nextActiveToolNames];
+            await this.emitOwn({
+                type: "tools_update",
+                toolNames: [...this.tools.keys()],
+                previousToolNames,
+                activeToolNames: [...this.activeToolNames],
+                previousActiveToolNames,
+                source: "set",
+            });
+        }
+        catch (error) {
+            throw normalizeHarnessError(error, "invalid_argument");
+        }
+    }
+    getActiveTools() {
+        return this.activeToolNames.map((name) => this.tools.get(name));
+    }
     async setActiveTools(toolNames) {
         try {
             this.validateToolNames(toolNames);
+            const previousToolNames = [...this.tools.keys()];
+            const previousActiveToolNames = [...this.activeToolNames];
+            if (this.phase === "idle") {
+                await this.session.appendActiveToolsChange(toolNames);
+            }
+            else {
+                this.pendingSessionWrites.push({ type: "active_tools_change", activeToolNames: [...toolNames] });
+            }
             this.activeToolNames = [...toolNames];
+            await this.emitOwn({
+                type: "tools_update",
+                toolNames: [...this.tools.keys()],
+                previousToolNames,
+                activeToolNames: [...this.activeToolNames],
+                previousActiveToolNames,
+                source: "set",
+            });
         }
         catch (error) {
             throw normalizeHarnessError(error, "invalid_argument");
@@ -832,18 +907,6 @@ export class AgentHarness {
     async setStreamOptions(streamOptions) {
         this.streamOptions = cloneStreamOptions(streamOptions);
     }
-    async setTools(tools, activeToolNames) {
-        try {
-            const nextTools = new Map(tools.map((tool) => [tool.name, tool]));
-            const nextActiveToolNames = activeToolNames ? [...activeToolNames] : this.activeToolNames;
-            this.validateToolNames(nextActiveToolNames, nextTools);
-            this.tools = nextTools;
-            this.activeToolNames = [...nextActiveToolNames];
-        }
-        catch (error) {
-            throw normalizeHarnessError(error, "invalid_argument");
-        }
-    }
     async abort() {
         const clearedSteer = [...this.steerQueue];
         const clearedFollowUp = [...this.followUpQueue];

package/node_modules/@earendil-works/pi-agent-core/dist/harness/compaction/branch-summarization.js

@@ -43,6 +43,7 @@ function getMessageFromEntry(entry) {
             return createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp);
         case "thinking_level_change":
         case "model_change":
+        case "active_tools_change":
         case "custom":
         case "label":
         case "session_info":

package/node_modules/@earendil-works/pi-agent-core/dist/harness/compaction/compaction.js

@@ -204,6 +204,7 @@ function findValidCutPoints(entries, startIndex, endIndex) {
             }
             case "thinking_level_change":
             case "model_change":
+            case "active_tools_change":
             case "compaction":
             case "branch_summary":
             case "custom":

package/node_modules/@earendil-works/pi-agent-core/dist/harness/session/session.js

@@ -3,6 +3,7 @@ import { SessionError } from "../types.js";
 export function buildSessionContext(pathEntries) {
     let thinkingLevel = "off";
     let model = null;
+    let activeToolNames = null;
     let compaction = null;
     for (const entry of pathEntries) {
         if (entry.type === "thinking_level_change") {
@@ -14,6 +15,9 @@ export function buildSessionContext(pathEntries) {
         else if (entry.type === "message" && entry.message.role === "assistant") {
             model = { provider: entry.message.provider, modelId: entry.message.model };
         }
+        else if (entry.type === "active_tools_change") {
+            activeToolNames = [...entry.activeToolNames];
+        }
         else if (entry.type === "compaction") {
             compaction = entry;
         }
@@ -50,7 +54,7 @@ export function buildSessionContext(pathEntries) {
             appendMessage(entry);
         }
     }
-    return { messages, thinkingLevel, model };
+    return { messages, thinkingLevel, model, activeToolNames };
 }
 export class Session {
     storage;
@@ -118,6 +122,15 @@ export class Session {
             modelId,
         });
     }
+    async appendActiveToolsChange(activeToolNames) {
+        return this.appendTypedEntry({
+            type: "active_tools_change",
+            id: await this.storage.createEntryId(),
+            parentId: await this.storage.getLeafId(),
+            timestamp: new Date().toISOString(),
+            activeToolNames: [...activeToolNames],
+        });
+    }
     async appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromHook) {
         return this.appendTypedEntry({
             type: "compaction",

package/node_modules/@earendil-works/pi-agent-core/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@earendil-works/pi-agent-core",
-	"version": "0.75.5",
+	"version": "0.78.0",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -29,7 +29,7 @@
 		"prepublishOnly": "npm run clean && npm run build"
 	},
 	"dependencies": {
-		"@earendil-works/pi-ai": "^0.75.5",
+		"@earendil-works/pi-ai": "^0.78.0",
 		"ignore": "7.0.5",
 		"typebox": "1.1.38",
 		"yaml": "2.9.0"
@@ -45,7 +45,7 @@
 	"license": "MIT",
 	"repository": {
 		"type": "git",
-		"url": "git+https://github.com/earendil-works/pi-mono.git",
+		"url": "git+https://github.com/earendil-works/pi.git",
 		"directory": "packages/agent"
 	},
 	"engines": {