@dexto/tools-process 1.6.0 → 1.6.2

package/dist/index.d.cts

@@ -1,13 +1,485 @@
-export { processToolsFactory } from './tool-factory.cjs';
-export { ProcessService } from './process-service.cjs';
-export { CommandValidator } from './command-validator.cjs';
-export { ProcessError } from './errors.cjs';
-export { ProcessErrorCode } from './error-codes.cjs';
-export { CommandValidation, ExecuteOptions, OutputBuffer, ProcessConfig, ProcessHandle, ProcessInfo, ProcessOutput, ProcessResult } from './types.cjs';
-export { createBashExecTool } from './bash-exec-tool.cjs';
-export { createBashOutputTool } from './bash-output-tool.cjs';
-export { createKillProcessTool } from './kill-process-tool.cjs';
-import '@dexto/agent-config';
-import './tool-factory-config.cjs';
-import 'zod';
-import '@dexto/core';
+import { ToolFactory } from '@dexto/agent-config';
+import { z } from 'zod';
+import { Logger, DextoRuntimeError, ToolExecutionContext, Tool } from '@dexto/core';
+
+/**
+ * Process Tools Factory
+ *
+ * Provides process execution and management tools by wrapping ProcessService.
+ * When registered, the factory initializes ProcessService and creates tools
+ * for command execution and process management.
+ */
+
+/**
+ * Configuration schema for Process tools factory.
+ *
+ * This is the SINGLE SOURCE OF TRUTH for all configuration:
+ * - Validation rules
+ * - Default values (using constants above)
+ * - Documentation
+ * - Type definitions
+ *
+ * Services receive fully-validated config from this schema and use it as-is,
+ * with no additional defaults or fallbacks needed.
+ */
+declare const ProcessToolsConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"process-tools">;
+    securityLevel: z.ZodDefault<z.ZodEnum<["strict", "moderate", "permissive"]>>;
+    maxTimeout: z.ZodDefault<z.ZodNumber>;
+    maxConcurrentProcesses: z.ZodDefault<z.ZodNumber>;
+    maxOutputBuffer: z.ZodDefault<z.ZodNumber>;
+    workingDirectory: z.ZodOptional<z.ZodString>;
+    allowedCommands: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    blockedCommands: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    environment: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strict", z.ZodTypeAny, {
+    securityLevel: "strict" | "moderate" | "permissive";
+    maxTimeout: number;
+    maxConcurrentProcesses: number;
+    maxOutputBuffer: number;
+    allowedCommands: string[];
+    blockedCommands: string[];
+    environment: Record<string, string>;
+    type: "process-tools";
+    workingDirectory?: string | undefined;
+}, {
+    type: "process-tools";
+    securityLevel?: "strict" | "moderate" | "permissive" | undefined;
+    maxTimeout?: number | undefined;
+    maxConcurrentProcesses?: number | undefined;
+    maxOutputBuffer?: number | undefined;
+    allowedCommands?: string[] | undefined;
+    blockedCommands?: string[] | undefined;
+    environment?: Record<string, string> | undefined;
+    workingDirectory?: string | undefined;
+}>;
+type ProcessToolsConfig = z.output<typeof ProcessToolsConfigSchema>;
+
+declare const processToolsFactory: ToolFactory<ProcessToolsConfig>;
+
+/**
+ * Process Service Types
+ *
+ * Types and interfaces for command execution and process management
+ */
+/**
+ * Process execution options
+ */
+interface ExecuteOptions {
+    /** Working directory */
+    cwd?: string | undefined;
+    /** Timeout in milliseconds (max: 600000) */
+    timeout?: number | undefined;
+    /** Run command in background */
+    runInBackground?: boolean | undefined;
+    /** Environment variables */
+    env?: Record<string, string> | undefined;
+    /** Description of what the command does (5-10 words) */
+    description?: string | undefined;
+    /** Abort signal for cancellation support */
+    abortSignal?: AbortSignal | undefined;
+}
+/**
+ * Process execution result (foreground execution only)
+ * For background execution, see ProcessHandle
+ */
+interface ProcessResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    duration: number;
+}
+/**
+ * Background process handle
+ */
+interface ProcessHandle {
+    processId: string;
+    command: string;
+    pid?: number | undefined;
+    startedAt: Date;
+    description?: string | undefined;
+}
+/**
+ * Process output (for retrieving from background processes)
+ */
+interface ProcessOutput {
+    stdout: string;
+    stderr: string;
+    status: 'running' | 'completed' | 'failed';
+    exitCode?: number | undefined;
+    duration?: number | undefined;
+}
+/**
+ * Process information
+ */
+interface ProcessInfo {
+    processId: string;
+    command: string;
+    pid?: number | undefined;
+    status: 'running' | 'completed' | 'failed';
+    startedAt: Date;
+    completedAt?: Date | undefined;
+    exitCode?: number | undefined;
+    description?: string | undefined;
+}
+/**
+ * Command validation result
+ */
+interface CommandValidation {
+    isValid: boolean;
+    error?: string;
+    normalizedCommand?: string;
+    requiresApproval?: boolean;
+}
+/**
+ * Process service configuration
+ */
+interface ProcessConfig {
+    /** Security level for command execution */
+    securityLevel: 'strict' | 'moderate' | 'permissive';
+    /** Maximum timeout for commands in milliseconds */
+    maxTimeout: number;
+    /** Maximum concurrent background processes */
+    maxConcurrentProcesses: number;
+    /** Maximum output buffer size in bytes */
+    maxOutputBuffer: number;
+    /** Explicitly allowed commands (empty = all allowed with approval) */
+    allowedCommands: string[];
+    /** Blocked command patterns */
+    blockedCommands: string[];
+    /** Custom environment variables */
+    environment: Record<string, string>;
+    /** Working directory (defaults to process.cwd()) */
+    workingDirectory?: string | undefined;
+}
+/**
+ * Output buffer management
+ */
+interface OutputBuffer {
+    stdout: string[];
+    stderr: string[];
+    complete: boolean;
+    lastRead: number;
+    bytesUsed: number;
+    truncated?: boolean;
+}
+
+/**
+ * Process Service
+ *
+ * Secure command execution and process management for Dexto internal tools
+ */
+
+/**
+ * ProcessService - Handles command execution and process management
+ *
+ * This service receives fully-validated configuration from the Process Tools Factory.
+ * All defaults have been applied by the factory's schema, so the service trusts the config
+ * and uses it as-is without any fallback logic.
+ *
+ * TODO: Add tests for this class
+ */
+declare class ProcessService {
+    private config;
+    private commandValidator;
+    private initialized;
+    private initPromise;
+    private backgroundProcesses;
+    private logger;
+    /**
+     * Create a new ProcessService with validated configuration.
+     *
+     * @param config - Fully-validated configuration from the factory schema.
+     *                 All required fields have values, defaults already applied.
+     * @param logger - Logger instance for this service
+     */
+    constructor(config: ProcessConfig, logger: Logger);
+    /**
+     * Initialize the service.
+     * Safe to call multiple times - subsequent calls return the same promise.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Internal initialization logic.
+     */
+    private doInitialize;
+    /**
+     * Ensure the service is initialized before use.
+     * Tools should call this at the start of their execute methods.
+     * Safe to call multiple times - will await the same initialization promise.
+     */
+    ensureInitialized(): Promise<void>;
+    /**
+     * Execute a command
+     */
+    executeCommand(command: string, options?: ExecuteOptions): Promise<ProcessResult | ProcessHandle>;
+    private static readonly SIGKILL_TIMEOUT_MS;
+    /**
+     * Kill a process tree (process group on Unix, taskkill on Windows)
+     */
+    private killProcessTree;
+    /**
+     * Execute command in foreground with timeout and abort support
+     */
+    private executeForeground;
+    /**
+     * Execute command in background
+     */
+    private executeInBackground;
+    /**
+     * Get output from a background process
+     */
+    getProcessOutput(processId: string): Promise<ProcessOutput>;
+    /**
+     * Kill a background process
+     */
+    killProcess(processId: string): Promise<void>;
+    /**
+     * List all background processes
+     */
+    listProcesses(): Promise<ProcessInfo[]>;
+    /**
+     * Get buffer size in bytes
+     */
+    private getBufferSize;
+    /**
+     * Get service configuration
+     */
+    getConfig(): Readonly<ProcessConfig>;
+    /**
+     * Update the working directory at runtime (e.g., when workspace changes).
+     */
+    setWorkingDirectory(workingDirectory: string): void;
+    /**
+     * Resolve and confine cwd to the configured working directory
+     */
+    private resolveSafeCwd;
+    /**
+     * Cleanup completed processes
+     */
+    cleanup(): Promise<void>;
+}
+
+/**
+ * Command Validator
+ *
+ * Security-focused command validation for process execution
+ */
+
+/**
+ * CommandValidator - Validates commands for security and policy compliance
+ *
+ * Security checks:
+ * 1. Command length limits
+ * 2. Dangerous command patterns
+ * 3. Command injection detection
+ * 4. Allowed/blocked command lists
+ * 5. Shell metacharacter analysis
+ * TODO: Add tests for this class
+ */
+declare class CommandValidator {
+    private config;
+    private logger;
+    constructor(config: ProcessConfig, logger: Logger);
+    /**
+     * Validate a command for security and policy compliance
+     */
+    validateCommand(command: string): CommandValidation;
+    /**
+     * Detect command injection attempts
+     */
+    private detectInjection;
+    /**
+     * Determine if a command requires approval
+     * Handles compound commands (with &&, ||, ;) by checking each sub-command
+     */
+    private determineApprovalRequirement;
+    /**
+     * Get list of blocked commands
+     */
+    getBlockedCommands(): string[];
+    /**
+     * Get list of allowed commands
+     */
+    getAllowedCommands(): string[];
+    /**
+     * Get security level
+     */
+    getSecurityLevel(): string;
+}
+
+/**
+ * Process Service Errors
+ *
+ * Error classes for process execution and management
+ */
+
+/**
+ * Factory class for creating Process-related errors
+ */
+declare class ProcessError {
+    private constructor();
+    /**
+     * Invalid command error
+     */
+    static invalidCommand(command: string, reason: string): DextoRuntimeError;
+    /**
+     * Command blocked error
+     */
+    static commandBlocked(command: string, reason: string): DextoRuntimeError;
+    /**
+     * Command too long error
+     */
+    static commandTooLong(length: number, maxLength: number): DextoRuntimeError;
+    /**
+     * Command injection detected error
+     */
+    static commandInjection(command: string, pattern: string): DextoRuntimeError;
+    /**
+     * Command approval required error
+     */
+    static approvalRequired(command: string, reason?: string): DextoRuntimeError;
+    /**
+     * Command approval denied error
+     */
+    static approvalDenied(command: string): DextoRuntimeError;
+    /**
+     * Command execution failed error
+     */
+    static executionFailed(command: string, cause: string): DextoRuntimeError;
+    /**
+     * Command timeout error
+     */
+    static timeout(command: string, timeout: number): DextoRuntimeError;
+    /**
+     * Permission denied error
+     */
+    static permissionDenied(command: string): DextoRuntimeError;
+    /**
+     * Command not found error
+     */
+    static commandNotFound(command: string): DextoRuntimeError;
+    /**
+     * Invalid working directory error
+     */
+    static invalidWorkingDirectory(path: string, reason: string): DextoRuntimeError;
+    /**
+     * Process not found error
+     */
+    static processNotFound(processId: string): DextoRuntimeError;
+    /**
+     * Too many concurrent processes error
+     */
+    static tooManyProcesses(current: number, max: number): DextoRuntimeError;
+    /**
+     * Kill process failed error
+     */
+    static killFailed(processId: string, cause: string): DextoRuntimeError;
+    /**
+     * Output buffer full error
+     */
+    static outputBufferFull(processId: string, size: number, maxSize: number): DextoRuntimeError;
+    /**
+     * Invalid configuration error
+     */
+    static invalidConfig(reason: string): DextoRuntimeError;
+    /**
+     * Service not initialized error
+     */
+    static notInitialized(): DextoRuntimeError;
+}
+
+/**
+ * Process Service Error Codes
+ *
+ * Standardized error codes for process execution and management
+ */
+declare enum ProcessErrorCode {
+    INVALID_COMMAND = "PROCESS_INVALID_COMMAND",
+    COMMAND_BLOCKED = "PROCESS_COMMAND_BLOCKED",
+    COMMAND_TOO_LONG = "PROCESS_COMMAND_TOO_LONG",
+    INJECTION_DETECTED = "PROCESS_INJECTION_DETECTED",
+    APPROVAL_REQUIRED = "PROCESS_APPROVAL_REQUIRED",
+    APPROVAL_DENIED = "PROCESS_APPROVAL_DENIED",
+    EXECUTION_FAILED = "PROCESS_EXECUTION_FAILED",
+    TIMEOUT = "PROCESS_TIMEOUT",
+    PERMISSION_DENIED = "PROCESS_PERMISSION_DENIED",
+    COMMAND_NOT_FOUND = "PROCESS_COMMAND_NOT_FOUND",
+    WORKING_DIRECTORY_INVALID = "PROCESS_WORKING_DIRECTORY_INVALID",
+    PROCESS_NOT_FOUND = "PROCESS_NOT_FOUND",
+    TOO_MANY_PROCESSES = "PROCESS_TOO_MANY_PROCESSES",
+    KILL_FAILED = "PROCESS_KILL_FAILED",
+    OUTPUT_BUFFER_FULL = "PROCESS_OUTPUT_BUFFER_FULL",
+    INVALID_CONFIG = "PROCESS_INVALID_CONFIG",
+    SERVICE_NOT_INITIALIZED = "PROCESS_SERVICE_NOT_INITIALIZED"
+}
+
+/**
+ * Bash Execute Tool
+ *
+ * Internal tool for executing shell commands.
+ * Pattern-based approval support is declared on the tool (ToolManager stays generic).
+ */
+
+declare const BashExecInputSchema: z.ZodObject<{
+    command: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    run_in_background: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    command: string;
+    timeout: number;
+    run_in_background: boolean;
+    cwd?: string | undefined;
+    description?: string | undefined;
+}, {
+    command: string;
+    timeout?: number | undefined;
+    cwd?: string | undefined;
+    description?: string | undefined;
+    run_in_background?: boolean | undefined;
+}>;
+/**
+ * Create the bash_exec internal tool
+ */
+type ProcessServiceGetter = (context: ToolExecutionContext) => Promise<ProcessService>;
+declare function createBashExecTool(getProcessService: ProcessServiceGetter): Tool<typeof BashExecInputSchema>;
+
+/**
+ * Bash Output Tool
+ *
+ * Internal tool for retrieving output from background processes
+ */
+
+declare const BashOutputInputSchema: z.ZodObject<{
+    process_id: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    process_id: string;
+}, {
+    process_id: string;
+}>;
+/**
+ * Create the bash_output internal tool
+ */
+declare function createBashOutputTool(getProcessService: ProcessServiceGetter): Tool<typeof BashOutputInputSchema>;
+
+/**
+ * Kill Process Tool
+ *
+ * Internal tool for terminating background processes
+ */
+
+declare const KillProcessInputSchema: z.ZodObject<{
+    process_id: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    process_id: string;
+}, {
+    process_id: string;
+}>;
+/**
+ * Create the kill_process internal tool
+ */
+declare function createKillProcessTool(getProcessService: ProcessServiceGetter): Tool<typeof KillProcessInputSchema>;
+
+export { type CommandValidation, CommandValidator, type ExecuteOptions, type OutputBuffer, type ProcessConfig, ProcessError, ProcessErrorCode, type ProcessHandle, type ProcessInfo, type ProcessOutput, type ProcessResult, ProcessService, type ProcessToolsConfig, ProcessToolsConfigSchema, createBashExecTool, createBashOutputTool, createKillProcessTool, processToolsFactory };

package/dist/index.d.ts

@@ -5,6 +5,7 @@
  * Provides process operation tools: bash exec, output, kill.
  */
 export { processToolsFactory } from './tool-factory.js';
+export { ProcessToolsConfigSchema, type ProcessToolsConfig } from './tool-factory-config.js';
 export { ProcessService } from './process-service.js';
 export { CommandValidator } from './command-validator.js';
 export { ProcessError } from './errors.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAGxD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAGpD,YAAY,EACR,aAAa,EACb,cAAc,EACd,aAAa,EACb,aAAa,EACb,aAAa,EACb,WAAW,EACX,iBAAiB,EACjB,YAAY,GACf,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,wBAAwB,EAAE,KAAK,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAG7F,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAGpD,YAAY,EACR,aAAa,EACb,cAAc,EACd,aAAa,EACb,aAAa,EACb,aAAa,EACb,WAAW,EACX,iBAAiB,EACjB,YAAY,GACf,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/index.js

@@ -1,4 +1,5 @@
 import { processToolsFactory } from "./tool-factory.js";
+import { ProcessToolsConfigSchema } from "./tool-factory-config.js";
 import { ProcessService } from "./process-service.js";
 import { CommandValidator } from "./command-validator.js";
 import { ProcessError } from "./errors.js";
@@ -11,6 +12,7 @@ export {
   ProcessError,
   ProcessErrorCode,
   ProcessService,
+  ProcessToolsConfigSchema,
   createBashExecTool,
   createBashOutputTool,
   createKillProcessTool,

package/dist/kill-process-tool.cjs

@@ -29,9 +29,14 @@ const KillProcessInputSchema = import_zod.z.object({
 function createKillProcessTool(getProcessService) {
   return (0, import_core.defineTool)({
     id: "kill_process",
-    displayName: "Kill",
     description: "Terminate a background process started with bash_exec. Sends SIGTERM signal first, then SIGKILL if process doesn't terminate within 5 seconds. Only works on processes started by this agent. Returns success status and whether the process was running. Does not require additional approval (process was already approved when started).",
     inputSchema: KillProcessInputSchema,
+    presentation: {
+      describeHeader: (input) => (0, import_core.createLocalToolCallHeader)({
+        title: "Kill",
+        argsText: (0, import_core.truncateForHeader)(input.process_id, 80)
+      })
+    },
     async execute(input, context) {
       const resolvedProcessService = await getProcessService(context);
       const { process_id } = input;

package/dist/kill-process-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"kill-process-tool.d.ts","sourceRoot":"","sources":["../src/kill-process-tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAEhE,QAAA,MAAM,sBAAsB;;;;;;EAIf,CAAC;AAEd;;GAEG;AACH,wBAAgB,qBAAqB,CACjC,iBAAiB,EAAE,oBAAoB,GACxC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAwBrC"}
+{"version":3,"file":"kill-process-tool.d.ts","sourceRoot":"","sources":["../src/kill-process-tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAEhE,QAAA,MAAM,sBAAsB;;;;;;EAIf,CAAC;AAEd;;GAEG;AACH,wBAAgB,qBAAqB,CACjC,iBAAiB,EAAE,oBAAoB,GACxC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CA8BrC"}

package/dist/kill-process-tool.js

@@ -1,14 +1,19 @@
 import { z } from "zod";
-import { defineTool } from "@dexto/core";
+import { createLocalToolCallHeader, defineTool, truncateForHeader } from "@dexto/core";
 const KillProcessInputSchema = z.object({
   process_id: z.string().describe("Process ID of the background process to terminate")
 }).strict();
 function createKillProcessTool(getProcessService) {
   return defineTool({
     id: "kill_process",
-    displayName: "Kill",
     description: "Terminate a background process started with bash_exec. Sends SIGTERM signal first, then SIGKILL if process doesn't terminate within 5 seconds. Only works on processes started by this agent. Returns success status and whether the process was running. Does not require additional approval (process was already approved when started).",
     inputSchema: KillProcessInputSchema,
+    presentation: {
+      describeHeader: (input) => createLocalToolCallHeader({
+        title: "Kill",
+        argsText: truncateForHeader(input.process_id, 80)
+      })
+    },
     async execute(input, context) {
       const resolvedProcessService = await getProcessService(context);
       const { process_id } = input;

package/dist/tool-factory.cjs

@@ -50,7 +50,19 @@ const processToolsFactory = {
       const workingDirectory = resolveWorkingDirectory(context);
       service.setWorkingDirectory(workingDirectory);
     };
+    const resolveInjectedService = (context) => {
+      const candidate = context.services?.processService;
+      if (!candidate) return null;
+      if (candidate instanceof import_process_service.ProcessService) return candidate;
+      const hasMethods = typeof candidate.executeCommand === "function" && typeof candidate.killProcess === "function" && typeof candidate.setWorkingDirectory === "function" && typeof candidate.getConfig === "function";
+      return hasMethods ? candidate : null;
+    };
     const getProcessService = async (context) => {
+      const injectedService = resolveInjectedService(context);
+      if (injectedService) {
+        applyWorkspace(context, injectedService);
+        return injectedService;
+      }
       if (processService) {
         applyWorkspace(context, processService);
         return processService;

package/dist/tool-factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-factory.d.ts","sourceRoot":"","sources":["../src/tool-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAMvD,OAAO,EAA4B,KAAK,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAG7F,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,kBAAkB,CAuD/D,CAAC"}
+{"version":3,"file":"tool-factory.d.ts","sourceRoot":"","sources":["../src/tool-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAMvD,OAAO,EAA4B,KAAK,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAG7F,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,kBAAkB,CA0E/D,CAAC"}

package/dist/tool-factory.js

@@ -27,7 +27,19 @@ const processToolsFactory = {
       const workingDirectory = resolveWorkingDirectory(context);
       service.setWorkingDirectory(workingDirectory);
     };
+    const resolveInjectedService = (context) => {
+      const candidate = context.services?.processService;
+      if (!candidate) return null;
+      if (candidate instanceof ProcessService) return candidate;
+      const hasMethods = typeof candidate.executeCommand === "function" && typeof candidate.killProcess === "function" && typeof candidate.setWorkingDirectory === "function" && typeof candidate.getConfig === "function";
+      return hasMethods ? candidate : null;
+    };
     const getProcessService = async (context) => {
+      const injectedService = resolveInjectedService(context);
+      if (injectedService) {
+        applyWorkspace(context, injectedService);
+        return injectedService;
+      }
       if (processService) {
         applyWorkspace(context, processService);
         return processService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexto/tools-process",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "Process tools factory for Dexto agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -20,8 +20,8 @@
   ],
   "dependencies": {
     "zod": "^3.25.0",
-    "@dexto/agent-config": "1.6.0",
-    "@dexto/core": "1.6.0"
+    "@dexto/agent-config": "1.6.2",
+    "@dexto/core": "1.6.2"
   },
   "devDependencies": {
     "tsup": "^8.0.0",
@@ -32,7 +32,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsup",
+    "build": "tsup && node ../../scripts/clean-tsbuildinfo.mjs && tsc -b tsconfig.json --emitDeclarationOnly",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist"
   }

package/dist/bash-exec-tool.d.cts

@@ -1,38 +0,0 @@
-import { z } from 'zod';
-import { ToolExecutionContext, Tool } from '@dexto/core';
-import { ProcessService } from './process-service.cjs';
-import './types.cjs';
-
-/**
- * Bash Execute Tool
- *
- * Internal tool for executing shell commands.
- * Pattern-based approval support is declared on the tool (ToolManager stays generic).
- */
-
-declare const BashExecInputSchema: z.ZodObject<{
-    command: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    run_in_background: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    cwd: z.ZodOptional<z.ZodString>;
-}, "strict", z.ZodTypeAny, {
-    command: string;
-    timeout: number;
-    run_in_background: boolean;
-    description?: string | undefined;
-    cwd?: string | undefined;
-}, {
-    command: string;
-    description?: string | undefined;
-    timeout?: number | undefined;
-    run_in_background?: boolean | undefined;
-    cwd?: string | undefined;
-}>;
-/**
- * Create the bash_exec internal tool
- */
-type ProcessServiceGetter = (context: ToolExecutionContext) => Promise<ProcessService>;
-declare function createBashExecTool(getProcessService: ProcessServiceGetter): Tool<typeof BashExecInputSchema>;
-
-export { type ProcessServiceGetter, createBashExecTool };